Medusa Coverage Report GitHub

Files

    Files
    49
    Total Lines
    25818
    Coverage
    37.5%
    193 / 514 lines
    Actions
    100.0% lib/aave-v3-core/contracts/dependencies/openzeppelin/contracts/Context.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.0;
    3
    
                                                    
                                                
    4
    /*
    5
     * @dev Provides information about the current execution context, including the
    6
     * sender of the transaction and its data. While these are generally available
    7
     * via msg.sender and msg.data, they should not be accessed in such a direct
    8
     * manner, since when dealing with GSN meta-transactions the account sending and
    9
     * paying for execution may not be the actual sender (as far as an application
    10
     * is concerned).
    11
     *
    12
     * This contract is only required for intermediate, library-like contracts.
    13
     */
    14
    abstract contract Context {
    15
      function _msgSender() internal view virtual returns (address payable) {
    16
    ✓ 1
        return payable(msg.sender);
    17
      }
    18
    
                                                    
                                                
    19
      function _msgData() internal view virtual returns (bytes memory) {
    20
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
    21
        return msg.data;
    22
      }
    23
    }
    24
    
                                                    
                                                
    71.4% lib/aave-v3-core/contracts/dependencies/openzeppelin/contracts/Ownable.sol
    Lines covered: 5 / 7 (71.4%)
    1
    // SPDX-License-Identifier: MIT
    2
    
                                                    
                                                
    3
    pragma solidity ^0.8.0;
    4
    
                                                    
                                                
    5
    import './Context.sol';
    6
    
                                                    
                                                
    7
    /**
    8
     * @dev Contract module which provides a basic access control mechanism, where
    9
     * there is an account (an owner) that can be granted exclusive access to
    10
     * specific functions.
    11
     *
    12
     * By default, the owner account will be the one that deploys the contract. This
    13
     * can later be changed with {transferOwnership}.
    14
     *
    15
     * This module is used through inheritance. It will make available the modifier
    16
     * `onlyOwner`, which can be applied to your functions to restrict their use to
    17
     * the owner.
    18
     */
    19
    contract Ownable is Context {
    20
      address private _owner;
    21
    
                                                    
                                                
    22
      event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    23
    
                                                    
                                                
    24
      /**
    25
       * @dev Initializes the contract setting the deployer as the initial owner.
    26
       */
    27
      constructor() {
    28
        address msgSender = _msgSender();
    29
    ✓ 1
        _owner = msgSender;
    30
    ✓ 1
        emit OwnershipTransferred(address(0), msgSender);
    31
      }
    32
    
                                                    
                                                
    33
      /**
    34
       * @dev Returns the address of the current owner.
    35
       */
    36
      function owner() public view returns (address) {
    37
        return _owner;
    38
      }
    39
    
                                                    
                                                
    40
      /**
    41
       * @dev Throws if called by any account other than the owner.
    42
       */
    43
      modifier onlyOwner() {
    44
    ✓ 1
        require(_owner == _msgSender(), 'Ownable: caller is not the owner');
    45
        _;
    46
      }
    47
    
                                                    
                                                
    48
      /**
    49
       * @dev Leaves the contract without owner. It will not be possible to call
    50
       * `onlyOwner` functions anymore. Can only be called by the current owner.
    51
       *
    52
       * NOTE: Renouncing ownership will leave the contract without an owner,
    53
       * thereby removing any functionality that is only available to the owner.
    54
       */
    55
      function renounceOwnership() public virtual onlyOwner {
    56
        emit OwnershipTransferred(_owner, address(0));
    57
        _owner = address(0);
    58
      }
    59
    
                                                    
                                                
    60
      /**
    61
       * @dev Transfers ownership of the contract to a new account (`newOwner`).
    62
       * Can only be called by the current owner.
    63
       */
    64
      function transferOwnership(address newOwner) public virtual onlyOwner {
    65
    ✓ 1
        require(newOwner != address(0), 'Ownable: new owner is the zero address');
    66
    ✓ 1
        emit OwnershipTransferred(_owner, newOwner);
    67
        _owner = newOwner;
    68
      }
    69
    }
    70
    
                                                    
                                                
    60.9% lib/aave-v3-core/contracts/dependencies/weth/WETH9.sol
    Lines covered: 14 / 23 (60.9%)
    1
    // Copyright (C) 2015, 2016, 2017 Dapphub
    2
    
                                                    
                                                
    3
    // This program is free software: you can redistribute it and/or modify
    4
    // it under the terms of the GNU General Public License as published by
    5
    // the Free Software Foundation, either version 3 of the License, or
    6
    // (at your option) any later version.
    7
    
                                                    
                                                
    8
    // This program is distributed in the hope that it will be useful,
    9
    // but WITHOUT ANY WARRANTY; without even the implied warranty of
    10
    // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    11
    // GNU General Public License for more details.
    12
    
                                                    
                                                
    13
    // You should have received a copy of the GNU General Public License
    14
    // along with this program.  If not, see <http://www.gnu.org/licenses/>.
    15
    
                                                    
                                                
    16
    pragma solidity ^0.8.10;
    17
    
                                                    
                                                
    18
    contract WETH9 {
    19
      string public name = 'Wrapped Ether';
    20
    ✓ 1
      string public symbol = 'WETH';
    21
    ✓ 1
      uint8 public decimals = 18;
    22
    
                                                    
                                                
    23
      event Approval(address indexed src, address indexed guy, uint256 wad);
    24
      event Transfer(address indexed src, address indexed dst, uint256 wad);
    25
      event Deposit(address indexed dst, uint256 wad);
    26
      event Withdrawal(address indexed src, uint256 wad);
    27
    
                                                    
                                                
    28
    ✓ 106
      mapping(address => uint256) public balanceOf;
    29
      mapping(address => mapping(address => uint256)) public allowance;
    30
    
                                                    
                                                
    31
      receive() external payable {
    32
        deposit();
    33
      }
    34
    
                                                    
                                                
    35
      function deposit() public payable {
    36
        balanceOf[msg.sender] += msg.value;
    37
        emit Deposit(msg.sender, msg.value);
    38
      }
    39
    
                                                    
                                                
    40
      function withdraw(uint256 wad) public {
    41
        require(balanceOf[msg.sender] >= wad);
    42
        balanceOf[msg.sender] -= wad;
    43
        payable(msg.sender).transfer(wad);
    44
        emit Withdrawal(msg.sender, wad);
    45
      }
    46
    
                                                    
                                                
    47
      function totalSupply() public view returns (uint256) {
    48
        return address(this).balance;
    49
      }
    50
    
                                                    
                                                
    51
      function approve(address guy, uint256 wad) public returns (bool) {
    52
    ✓ 1.4K
        allowance[msg.sender][guy] = wad;
    53
    ✓ 1.4K
        emit Approval(msg.sender, guy, wad);
    54
        return true;
    55
      }
    56
    
                                                    
                                                
    57
      function transfer(address dst, uint256 wad) public returns (bool) {
    58
    ✓ 557
        return transferFrom(msg.sender, dst, wad);
    59
      }
    60
    
                                                    
                                                
    61
      function transferFrom(address src, address dst, uint256 wad) public returns (bool) {
    62
    ✓ 2.0K
        require(balanceOf[src] >= wad);
    63
    
                                                    
                                                
    64
    ✓ 2.0K
        if (src != msg.sender && allowance[src][msg.sender] != type(uint256).max) {
    65
    ✓ 1.4K
          require(allowance[src][msg.sender] >= wad);
    66
    ✓ 1.4K
          allowance[src][msg.sender] -= wad;
    67
        }
    68
    
                                                    
                                                
    69
    ✓ 2.0K
        balanceOf[src] -= wad;
    70
    ✓ 2.0K
        balanceOf[dst] += wad;
    71
    
                                                    
                                                
    72
    ✓ 2.0K
        emit Transfer(src, dst, wad);
    73
    
                                                    
                                                
    74
    ✓ 2.0K
        return true;
    75
      }
    76
    }
    77
    
                                                    
                                                
    78
    /*
    79
                        GNU GENERAL PUBLIC LICENSE
    80
                           Version 3, 29 June 2007
    81
    
                                                    
                                                
    82
     Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
    83
     Everyone is permitted to copy and distribute verbatim copies
    84
     of this license document, but changing it is not allowed.
    85
    
                                                    
                                                
    86
                                Preamble
    87
    
                                                    
                                                
    88
      The GNU General Public License is a free, copyleft license for
    89
    software and other kinds of works.
    90
    
                                                    
                                                
    91
      The licenses for most software and other practical works are designed
    92
    to take away your freedom to share and change the works.  By contrast,
    93
    the GNU General Public License is intended to guarantee your freedom to
    94
    share and change all versions of a program--to make sure it remains free
    95
    software for all its users.  We, the Free Software Foundation, use the
    96
    GNU General Public License for most of our software; it applies also to
    97
    any other work released this way by its authors.  You can apply it to
    98
    your programs, too.
    99
    
                                                    
                                                
    100
      When we speak of free software, we are referring to freedom, not
    101
    price.  Our General Public Licenses are designed to make sure that you
    102
    have the freedom to distribute copies of free software (and charge for
    103
    them if you wish), that you receive source code or can get it if you
    104
    want it, that you can change the software or use pieces of it in new
    105
    free programs, and that you know you can do these things.
    106
    
                                                    
                                                
    107
      To protect your rights, we need to prevent others from denying you
    108
    these rights or asking you to surrender the rights.  Therefore, you have
    109
    certain responsibilities if you distribute copies of the software, or if
    110
    you modify it: responsibilities to respect the freedom of others.
    111
    
                                                    
                                                
    112
      For example, if you distribute copies of such a program, whether
    113
    gratis or for a fee, you must pass on to the recipients the same
    114
    freedoms that you received.  You must make sure that they, too, receive
    115
    or can get the source code.  And you must show them these terms so they
    116
    know their rights.
    117
    
                                                    
                                                
    118
      Developers that use the GNU GPL protect your rights with two steps:
    119
    (1) assert copyright on the software, and (2) offer you this License
    120
    giving you legal permission to copy, distribute and/or modify it.
    121
    
                                                    
                                                
    122
      For the developers' and authors' protection, the GPL clearly explains
    123
    that there is no warranty for this free software.  For both users' and
    124
    authors' sake, the GPL requires that modified versions be marked as
    125
    changed, so that their problems will not be attributed erroneously to
    126
    authors of previous versions.
    127
    
                                                    
                                                
    128
      Some devices are designed to deny users access to install or run
    129
    modified versions of the software inside them, although the manufacturer
    130
    can do so.  This is fundamentally incompatible with the aim of
    131
    protecting users' freedom to change the software.  The systematic
    132
    pattern of such abuse occurs in the area of products for individuals to
    133
    use, which is precisely where it is most unacceptable.  Therefore, we
    134
    have designed this version of the GPL to prohibit the practice for those
    135
    products.  If such problems arise substantially in other domains, we
    136
    stand ready to extend this provision to those domains in future versions
    137
    of the GPL, as needed to protect the freedom of users.
    138
    
                                                    
                                                
    139
      Finally, every program is threatened constantly by software patents.
    140
    States should not allow patents to restrict development and use of
    141
    software on general-purpose computers, but in those that do, we wish to
    142
    avoid the special danger that patents applied to a free program could
    143
    make it effectively proprietary.  To prevent this, the GPL assures that
    144
    patents cannot be used to render the program non-free.
    145
    
                                                    
                                                
    146
      The precise terms and conditions for copying, distribution and
    147
    modification follow.
    148
    
                                                    
                                                
    149
                           TERMS AND CONDITIONS
    150
    
                                                    
                                                
    151
      0. Definitions.
    152
    
                                                    
                                                
    153
      "This License" refers to version 3 of the GNU General Public License.
    154
    
                                                    
                                                
    155
      "Copyright" also means copyright-like laws that apply to other kinds of
    156
    works, such as semiconductor masks.
    157
    
                                                    
                                                
    158
      "The Program" refers to any copyrightable work licensed under this
    159
    License.  Each licensee is addressed as "you".  "Licensees" and
    160
    "recipients" may be individuals or organizations.
    161
    
                                                    
                                                
    162
      To "modify" a work means to copy from or adapt all or part of the work
    163
    in a fashion requiring copyright permission, other than the making of an
    164
    exact copy.  The resulting work is called a "modified version" of the
    165
    earlier work or a work "based on" the earlier work.
    166
    
                                                    
                                                
    167
      A "covered work" means either the unmodified Program or a work based
    168
    on the Program.
    169
    
                                                    
                                                
    170
      To "propagate" a work means to do anything with it that, without
    171
    permission, would make you directly or secondarily liable for
    172
    infringement under applicable copyright law, except executing it on a
    173
    computer or modifying a private copy.  Propagation includes copying,
    174
    distribution (with or without modification), making available to the
    175
    public, and in some countries other activities as well.
    176
    
                                                    
                                                
    177
      To "convey" a work means any kind of propagation that enables other
    178
    parties to make or receive copies.  Mere interaction with a user through
    179
    a computer network, with no transfer of a copy, is not conveying.
    180
    
                                                    
                                                
    181
      An interactive user interface displays "Appropriate Legal Notices"
    182
    to the extent that it includes a convenient and prominently visible
    183
    feature that (1) displays an appropriate copyright notice, and (2)
    184
    tells the user that there is no warranty for the work (except to the
    185
    extent that warranties are provided), that licensees may convey the
    186
    work under this License, and how to view a copy of this License.  If
    187
    the interface presents a list of user commands or options, such as a
    188
    menu, a prominent item in the list meets this criterion.
    189
    
                                                    
                                                
    190
      1. Source Code.
    191
    
                                                    
                                                
    192
      The "source code" for a work means the preferred form of the work
    193
    for making modifications to it.  "Object code" means any non-source
    194
    form of a work.
    195
    
                                                    
                                                
    196
      A "Standard Interface" means an interface that either is an official
    197
    standard defined by a recognized standards body, or, in the case of
    198
    interfaces specified for a particular programming language, one that
    199
    is widely used among developers working in that language.
    200
    
                                                    
                                                
    201
      The "System Libraries" of an executable work include anything, other
    202
    than the work as a whole, that (a) is included in the normal form of
    203
    packaging a Major Component, but which is not part of that Major
    204
    Component, and (b) serves only to enable use of the work with that
    205
    Major Component, or to implement a Standard Interface for which an
    206
    implementation is available to the public in source code form.  A
    207
    "Major Component", in this context, means a major essential component
    208
    (kernel, window system, and so on) of the specific operating system
    209
    (if any) on which the executable work runs, or a compiler used to
    210
    produce the work, or an object code interpreter used to run it.
    211
    
                                                    
                                                
    212
      The "Corresponding Source" for a work in object code form means all
    213
    the source code needed to generate, install, and (for an executable
    214
    work) run the object code and to modify the work, including scripts to
    215
    control those activities.  However, it does not include the work's
    216
    System Libraries, or general-purpose tools or generally available free
    217
    programs which are used unmodified in performing those activities but
    218
    which are not part of the work.  For example, Corresponding Source
    219
    includes interface definition files associated with source files for
    220
    the work, and the source code for shared libraries and dynamically
    221
    linked subprograms that the work is specifically designed to require,
    222
    such as by intimate data communication or control flow between those
    223
    subprograms and other parts of the work.
    224
    
                                                    
                                                
    225
      The Corresponding Source need not include anything that users
    226
    can regenerate automatically from other parts of the Corresponding
    227
    Source.
    228
    
                                                    
                                                
    229
      The Corresponding Source for a work in source code form is that
    230
    same work.
    231
    
                                                    
                                                
    232
      2. Basic Permissions.
    233
    
                                                    
                                                
    234
      All rights granted under this License are granted for the term of
    235
    copyright on the Program, and are irrevocable provided the stated
    236
    conditions are met.  This License explicitly affirms your unlimited
    237
    permission to run the unmodified Program.  The output from running a
    238
    covered work is covered by this License only if the output, given its
    239
    content, constitutes a covered work.  This License acknowledges your
    240
    rights of fair use or other equivalent, as provided by copyright law.
    241
    
                                                    
                                                
    242
      You may make, run and propagate covered works that you do not
    243
    convey, without conditions so long as your license otherwise remains
    244
    in force.  You may convey covered works to others for the sole purpose
    245
    of having them make modifications exclusively for you, or provide you
    246
    with facilities for running those works, provided that you comply with
    247
    the terms of this License in conveying all material for which you do
    248
    not control copyright.  Those thus making or running the covered works
    249
    for you must do so exclusively on your behalf, under your direction
    250
    and control, on terms that prohibit them from making any copies of
    251
    your copyrighted material outside their relationship with you.
    252
    
                                                    
                                                
    253
      Conveying under any other circumstances is permitted solely under
    254
    the conditions stated below.  Sublicensing is not allowed; section 10
    255
    makes it unnecessary.
    256
    
                                                    
                                                
    257
      3. Protecting Users' Legal Rights From Anti-Circumvention Law.
    258
    
                                                    
                                                
    259
      No covered work shall be deemed part of an effective technological
    260
    measure under any applicable law fulfilling obligations under article
    261
    11 of the WIPO copyright treaty adopted on 20 December 1996, or
    262
    similar laws prohibiting or restricting circumvention of such
    263
    measures.
    264
    
                                                    
                                                
    265
      When you convey a covered work, you waive any legal power to forbid
    266
    circumvention of technological measures to the extent such circumvention
    267
    is effected by exercising rights under this License with respect to
    268
    the covered work, and you disclaim any intention to limit operation or
    269
    modification of the work as a means of enforcing, against the work's
    270
    users, your or third parties' legal rights to forbid circumvention of
    271
    technological measures.
    272
    
                                                    
                                                
    273
      4. Conveying Verbatim Copies.
    274
    
                                                    
                                                
    275
      You may convey verbatim copies of the Program's source code as you
    276
    receive it, in any medium, provided that you conspicuously and
    277
    appropriately publish on each copy an appropriate copyright notice;
    278
    keep intact all notices stating that this License and any
    279
    non-permissive terms added in accord with section 7 apply to the code;
    280
    keep intact all notices of the absence of any warranty; and give all
    281
    recipients a copy of this License along with the Program.
    282
    
                                                    
                                                
    283
      You may charge any price or no price for each copy that you convey,
    284
    and you may offer support or warranty protection for a fee.
    285
    
                                                    
                                                
    286
      5. Conveying Modified Source Versions.
    287
    
                                                    
                                                
    288
      You may convey a work based on the Program, or the modifications to
    289
    produce it from the Program, in the form of source code under the
    290
    terms of section 4, provided that you also meet all of these conditions:
    291
    
                                                    
                                                
    292
        a) The work must carry prominent notices stating that you modified
    293
        it, and giving a relevant date.
    294
    
                                                    
                                                
    295
        b) The work must carry prominent notices stating that it is
    296
        released under this License and any conditions added under section
    297
        7.  This requirement modifies the requirement in section 4 to
    298
        "keep intact all notices".
    299
    
                                                    
                                                
    300
        c) You must license the entire work, as a whole, under this
    301
        License to anyone who comes into possession of a copy.  This
    302
        License will therefore apply, along with any applicable section 7
    303
        additional terms, to the whole of the work, and all its parts,
    304
        regardless of how they are packaged.  This License gives no
    305
        permission to license the work in any other way, but it does not
    306
        invalidate such permission if you have separately received it.
    307
    
                                                    
                                                
    308
        d) If the work has interactive user interfaces, each must display
    309
        Appropriate Legal Notices; however, if the Program has interactive
    310
        interfaces that do not display Appropriate Legal Notices, your
    311
        work need not make them do so.
    312
    
                                                    
                                                
    313
      A compilation of a covered work with other separate and independent
    314
    works, which are not by their nature extensions of the covered work,
    315
    and which are not combined with it such as to form a larger program,
    316
    in or on a volume of a storage or distribution medium, is called an
    317
    "aggregate" if the compilation and its resulting copyright are not
    318
    used to limit the access or legal rights of the compilation's users
    319
    beyond what the individual works permit.  Inclusion of a covered work
    320
    in an aggregate does not cause this License to apply to the other
    321
    parts of the aggregate.
    322
    
                                                    
                                                
    323
      6. Conveying Non-Source Forms.
    324
    
                                                    
                                                
    325
      You may convey a covered work in object code form under the terms
    326
    of sections 4 and 5, provided that you also convey the
    327
    machine-readable Corresponding Source under the terms of this License,
    328
    in one of these ways:
    329
    
                                                    
                                                
    330
        a) Convey the object code in, or embodied in, a physical product
    331
        (including a physical distribution medium), accompanied by the
    332
        Corresponding Source fixed on a durable physical medium
    333
        customarily used for software interchange.
    334
    
                                                    
                                                
    335
        b) Convey the object code in, or embodied in, a physical product
    336
        (including a physical distribution medium), accompanied by a
    337
        written offer, valid for at least three years and valid for as
    338
        long as you offer spare parts or customer support for that product
    339
        model, to give anyone who possesses the object code either (1) a
    340
        copy of the Corresponding Source for all the software in the
    341
        product that is covered by this License, on a durable physical
    342
        medium customarily used for software interchange, for a price no
    343
        more than your reasonable cost of physically performing this
    344
        conveying of source, or (2) access to copy the
    345
        Corresponding Source from a network server at no charge.
    346
    
                                                    
                                                
    347
        c) Convey individual copies of the object code with a copy of the
    348
        written offer to provide the Corresponding Source.  This
    349
        alternative is allowed only occasionally and noncommercially, and
    350
        only if you received the object code with such an offer, in accord
    351
        with subsection 6b.
    352
    
                                                    
                                                
    353
        d) Convey the object code by offering access from a designated
    354
        place (gratis or for a charge), and offer equivalent access to the
    355
        Corresponding Source in the same way through the same place at no
    356
        further charge.  You need not require recipients to copy the
    357
        Corresponding Source along with the object code.  If the place to
    358
        copy the object code is a network server, the Corresponding Source
    359
        may be on a different server (operated by you or a third party)
    360
        that supports equivalent copying facilities, provided you maintain
    361
        clear directions next to the object code saying where to find the
    362
        Corresponding Source.  Regardless of what server hosts the
    363
        Corresponding Source, you remain obligated to ensure that it is
    364
        available for as long as needed to satisfy these requirements.
    365
    
                                                    
                                                
    366
        e) Convey the object code using peer-to-peer transmission, provided
    367
        you inform other peers where the object code and Corresponding
    368
        Source of the work are being offered to the general public at no
    369
        charge under subsection 6d.
    370
    
                                                    
                                                
    371
      A separable portion of the object code, whose source code is excluded
    372
    from the Corresponding Source as a System Library, need not be
    373
    included in conveying the object code work.
    374
    
                                                    
                                                
    375
      A "User Product" is either (1) a "consumer product", which means any
    376
    tangible personal property which is normally used for personal, family,
    377
    or household purposes, or (2) anything designed or sold for incorporation
    378
    into a dwelling.  In determining whether a product is a consumer product,
    379
    doubtful cases shall be resolved in favor of coverage.  For a particular
    380
    product received by a particular user, "normally used" refers to a
    381
    typical or common use of that class of product, regardless of the status
    382
    of the particular user or of the way in which the particular user
    383
    actually uses, or expects or is expected to use, the product.  A product
    384
    is a consumer product regardless of whether the product has substantial
    385
    commercial, industrial or non-consumer uses, unless such uses represent
    386
    the only significant mode of use of the product.
    387
    
                                                    
                                                
    388
      "Installation Information" for a User Product means any methods,
    389
    procedures, authorization keys, or other information required to install
    390
    and execute modified versions of a covered work in that User Product from
    391
    a modified version of its Corresponding Source.  The information must
    392
    suffice to ensure that the continued functioning of the modified object
    393
    code is in no case prevented or interfered with solely because
    394
    modification has been made.
    395
    
                                                    
                                                
    396
      If you convey an object code work under this section in, or with, or
    397
    specifically for use in, a User Product, and the conveying occurs as
    398
    part of a transaction in which the right of possession and use of the
    399
    User Product is transferred to the recipient in perpetuity or for a
    400
    fixed term (regardless of how the transaction is characterized), the
    401
    Corresponding Source conveyed under this section must be accompanied
    402
    by the Installation Information.  But this requirement does not apply
    403
    if neither you nor any third party retains the ability to install
    404
    modified object code on the User Product (for example, the work has
    405
    been installed in ROM).
    406
    
                                                    
                                                
    407
      The requirement to provide Installation Information does not include a
    408
    requirement to continue to provide support service, warranty, or updates
    409
    for a work that has been modified or installed by the recipient, or for
    410
    the User Product in which it has been modified or installed.  Access to a
    411
    network may be denied when the modification itself materially and
    412
    adversely affects the operation of the network or violates the rules and
    413
    protocols for communication across the network.
    414
    
                                                    
                                                
    415
      Corresponding Source conveyed, and Installation Information provided,
    416
    in accord with this section must be in a format that is publicly
    417
    documented (and with an implementation available to the public in
    418
    source code form), and must require no special password or key for
    419
    unpacking, reading or copying.
    420
    
                                                    
                                                
    421
      7. Additional Terms.
    422
    
                                                    
                                                
    423
      "Additional permissions" are terms that supplement the terms of this
    424
    License by making exceptions from one or more of its conditions.
    425
    Additional permissions that are applicable to the entire Program shall
    426
    be treated as though they were included in this License, to the extent
    427
    that they are valid under applicable law.  If additional permissions
    428
    apply only to part of the Program, that part may be used separately
    429
    under those permissions, but the entire Program remains governed by
    430
    this License without regard to the additional permissions.
    431
    
                                                    
                                                
    432
      When you convey a copy of a covered work, you may at your option
    433
    remove any additional permissions from that copy, or from any part of
    434
    it.  (Additional permissions may be written to require their own
    435
    removal in certain cases when you modify the work.)  You may place
    436
    additional permissions on material, added by you to a covered work,
    437
    for which you have or can give appropriate copyright permission.
    438
    
                                                    
                                                
    439
      Notwithstanding any other provision of this License, for material you
    440
    add to a covered work, you may (if authorized by the copyright holders of
    441
    that material) supplement the terms of this License with terms:
    442
    
                                                    
                                                
    443
        a) Disclaiming warranty or limiting liability differently from the
    444
        terms of sections 15 and 16 of this License; or
    445
    
                                                    
                                                
    446
        b) Requiring preservation of specified reasonable legal notices or
    447
        author attributions in that material or in the Appropriate Legal
    448
        Notices displayed by works containing it; or
    449
    
                                                    
                                                
    450
        c) Prohibiting misrepresentation of the origin of that material, or
    451
        requiring that modified versions of such material be marked in
    452
        reasonable ways as different from the original version; or
    453
    
                                                    
                                                
    454
        d) Limiting the use for publicity purposes of names of licensors or
    455
        authors of the material; or
    456
    
                                                    
                                                
    457
        e) Declining to grant rights under trademark law for use of some
    458
        trade names, trademarks, or service marks; or
    459
    
                                                    
                                                
    460
        f) Requiring indemnification of licensors and authors of that
    461
        material by anyone who conveys the material (or modified versions of
    462
        it) with contractual assumptions of liability to the recipient, for
    463
        any liability that these contractual assumptions directly impose on
    464
        those licensors and authors.
    465
    
                                                    
                                                
    466
      All other non-permissive additional terms are considered "further
    467
    restrictions" within the meaning of section 10.  If the Program as you
    468
    received it, or any part of it, contains a notice stating that it is
    469
    governed by this License along with a term that is a further
    470
    restriction, you may remove that term.  If a license document contains
    471
    a further restriction but permits relicensing or conveying under this
    472
    License, you may add to a covered work material governed by the terms
    473
    of that license document, provided that the further restriction does
    474
    not survive such relicensing or conveying.
    475
    
                                                    
                                                
    476
      If you add terms to a covered work in accord with this section, you
    477
    must place, in the relevant source files, a statement of the
    478
    additional terms that apply to those files, or a notice indicating
    479
    where to find the applicable terms.
    480
    
                                                    
                                                
    481
      Additional terms, permissive or non-permissive, may be stated in the
    482
    form of a separately written license, or stated as exceptions;
    483
    the above requirements apply either way.
    484
    
                                                    
                                                
    485
      8. Termination.
    486
    
                                                    
                                                
    487
      You may not propagate or modify a covered work except as expressly
    488
    provided under this License.  Any attempt otherwise to propagate or
    489
    modify it is void, and will automatically terminate your rights under
    490
    this License (including any patent licenses granted under the third
    491
    paragraph of section 11).
    492
    
                                                    
                                                
    493
      However, if you cease all violation of this License, then your
    494
    license from a particular copyright holder is reinstated (a)
    495
    provisionally, unless and until the copyright holder explicitly and
    496
    finally terminates your license, and (b) permanently, if the copyright
    497
    holder fails to notify you of the violation by some reasonable means
    498
    prior to 60 days after the cessation.
    499
    
                                                    
                                                
    500
      Moreover, your license from a particular copyright holder is
    501
    reinstated permanently if the copyright holder notifies you of the
    502
    violation by some reasonable means, this is the first time you have
    503
    received notice of violation of this License (for any work) from that
    504
    copyright holder, and you cure the violation prior to 30 days after
    505
    your receipt of the notice.
    506
    
                                                    
                                                
    507
      Termination of your rights under this section does not terminate the
    508
    licenses of parties who have received copies or rights from you under
    509
    this License.  If your rights have been terminated and not permanently
    510
    reinstated, you do not qualify to receive new licenses for the same
    511
    material under section 10.
    512
    
                                                    
                                                
    513
      9. Acceptance Not Required for Having Copies.
    514
    
                                                    
                                                
    515
      You are not required to accept this License in order to receive or
    516
    run a copy of the Program.  Ancillary propagation of a covered work
    517
    occurring solely as a consequence of using peer-to-peer transmission
    518
    to receive a copy likewise does not require acceptance.  However,
    519
    nothing other than this License grants you permission to propagate or
    520
    modify any covered work.  These actions infringe copyright if you do
    521
    not accept this License.  Therefore, by modifying or propagating a
    522
    covered work, you indicate your acceptance of this License to do so.
    523
    
                                                    
                                                
    524
      10. Automatic Licensing of Downstream Recipients.
    525
    
                                                    
                                                
    526
      Each time you convey a covered work, the recipient automatically
    527
    receives a license from the original licensors, to run, modify and
    528
    propagate that work, subject to this License.  You are not responsible
    529
    for enforcing compliance by third parties with this License.
    530
    
                                                    
                                                
    531
      An "entity transaction" is a transaction transferring control of an
    532
    organization, or substantially all assets of one, or subdividing an
    533
    organization, or merging organizations.  If propagation of a covered
    534
    work results from an entity transaction, each party to that
    535
    transaction who receives a copy of the work also receives whatever
    536
    licenses to the work the party's predecessor in interest had or could
    537
    give under the previous paragraph, plus a right to possession of the
    538
    Corresponding Source of the work from the predecessor in interest, if
    539
    the predecessor has it or can get it with reasonable efforts.
    540
    
                                                    
                                                
    541
      You may not impose any further restrictions on the exercise of the
    542
    rights granted or affirmed under this License.  For example, you may
    543
    not impose a license fee, royalty, or other charge for exercise of
    544
    rights granted under this License, and you may not initiate litigation
    545
    (including a cross-claim or counterclaim in a lawsuit) alleging that
    546
    any patent claim is infringed by making, using, selling, offering for
    547
    sale, or importing the Program or any portion of it.
    548
    
                                                    
                                                
    549
      11. Patents.
    550
    
                                                    
                                                
    551
      A "contributor" is a copyright holder who authorizes use under this
    552
    License of the Program or a work on which the Program is based.  The
    553
    work thus licensed is called the contributor's "contributor version".
    554
    
                                                    
                                                
    555
      A contributor's "essential patent claims" are all patent claims
    556
    owned or controlled by the contributor, whether already acquired or
    557
    hereafter acquired, that would be infringed by some manner, permitted
    558
    by this License, of making, using, or selling its contributor version,
    559
    but do not include claims that would be infringed only as a
    560
    consequence of further modification of the contributor version.  For
    561
    purposes of this definition, "control" includes the right to grant
    562
    patent sublicenses in a manner consistent with the requirements of
    563
    this License.
    564
    
                                                    
                                                
    565
      Each contributor grants you a non-exclusive, worldwide, royalty-free
    566
    patent license under the contributor's essential patent claims, to
    567
    make, use, sell, offer for sale, import and otherwise run, modify and
    568
    propagate the contents of its contributor version.
    569
    
                                                    
                                                
    570
      In the following three paragraphs, a "patent license" is any express
    571
    agreement or commitment, however denominated, not to enforce a patent
    572
    (such as an express permission to practice a patent or covenant not to
    573
    sue for patent infringement).  To "grant" such a patent license to a
    574
    party means to make such an agreement or commitment not to enforce a
    575
    patent against the party.
    576
    
                                                    
                                                
    577
      If you convey a covered work, knowingly relying on a patent license,
    578
    and the Corresponding Source of the work is not available for anyone
    579
    to copy, free of charge and under the terms of this License, through a
    580
    publicly available network server or other readily accessible means,
    581
    then you must either (1) cause the Corresponding Source to be so
    582
    available, or (2) arrange to deprive yourself of the benefit of the
    583
    patent license for this particular work, or (3) arrange, in a manner
    584
    consistent with the requirements of this License, to extend the patent
    585
    license to downstream recipients.  "Knowingly relying" means you have
    586
    actual knowledge that, but for the patent license, your conveying the
    587
    covered work in a country, or your recipient's use of the covered work
    588
    in a country, would infringe one or more identifiable patents in that
    589
    country that you have reason to believe are valid.
    590
    
                                                    
                                                
    591
      If, pursuant to or in connection with a single transaction or
    592
    arrangement, you convey, or propagate by procuring conveyance of, a
    593
    covered work, and grant a patent license to some of the parties
    594
    receiving the covered work authorizing them to use, propagate, modify
    595
    or convey a specific copy of the covered work, then the patent license
    596
    you grant is automatically extended to all recipients of the covered
    597
    work and works based on it.
    598
    
                                                    
                                                
    599
      A patent license is "discriminatory" if it does not include within
    600
    the scope of its coverage, prohibits the exercise of, or is
    601
    conditioned on the non-exercise of one or more of the rights that are
    602
    specifically granted under this License.  You may not convey a covered
    603
    work if you are a party to an arrangement with a third party that is
    604
    in the business of distributing software, under which you make payment
    605
    to the third party based on the extent of your activity of conveying
    606
    the work, and under which the third party grants, to any of the
    607
    parties who would receive the covered work from you, a discriminatory
    608
    patent license (a) in connection with copies of the covered work
    609
    conveyed by you (or copies made from those copies), or (b) primarily
    610
    for and in connection with specific products or compilations that
    611
    contain the covered work, unless you entered into that arrangement,
    612
    or that patent license was granted, prior to 28 March 2007.
    613
    
                                                    
                                                
    614
      Nothing in this License shall be construed as excluding or limiting
    615
    any implied license or other defenses to infringement that may
    616
    otherwise be available to you under applicable patent law.
    617
    
                                                    
                                                
    618
      12. No Surrender of Others' Freedom.
    619
    
                                                    
                                                
    620
      If conditions are imposed on you (whether by court order, agreement or
    621
    otherwise) that contradict the conditions of this License, they do not
    622
    excuse you from the conditions of this License.  If you cannot convey a
    623
    covered work so as to satisfy simultaneously your obligations under this
    624
    License and any other pertinent obligations, then as a consequence you may
    625
    not convey it at all.  For example, if you agree to terms that obligate you
    626
    to collect a royalty for further conveying from those to whom you convey
    627
    the Program, the only way you could satisfy both those terms and this
    628
    License would be to refrain entirely from conveying the Program.
    629
    
                                                    
                                                
    630
      13. Use with the GNU Affero General Public License.
    631
    
                                                    
                                                
    632
      Notwithstanding any other provision of this License, you have
    633
    permission to link or combine any covered work with a work licensed
    634
    under version 3 of the GNU Affero General Public License into a single
    635
    combined work, and to convey the resulting work.  The terms of this
    636
    License will continue to apply to the part which is the covered work,
    637
    but the special requirements of the GNU Affero General Public License,
    638
    section 13, concerning interaction through a network will apply to the
    639
    combination as such.
    640
    
                                                    
                                                
    641
      14. Revised Versions of this License.
    642
    
                                                    
                                                
    643
      The Free Software Foundation may publish revised and/or new versions of
    644
    the GNU General Public License from time to time.  Such new versions will
    645
    be similar in spirit to the present version, but may differ in detail to
    646
    address new problems or concerns.
    647
    
                                                    
                                                
    648
      Each version is given a distinguishing version number.  If the
    649
    Program specifies that a certain numbered version of the GNU General
    650
    Public License "or any later version" applies to it, you have the
    651
    option of following the terms and conditions either of that numbered
    652
    version or of any later version published by the Free Software
    653
    Foundation.  If the Program does not specify a version number of the
    654
    GNU General Public License, you may choose any version ever published
    655
    by the Free Software Foundation.
    656
    
                                                    
                                                
    657
      If the Program specifies that a proxy can decide which future
    658
    versions of the GNU General Public License can be used, that proxy's
    659
    public statement of acceptance of a version permanently authorizes you
    660
    to choose that version for the Program.
    661
    
                                                    
                                                
    662
      Later license versions may give you additional or different
    663
    permissions.  However, no additional obligations are imposed on any
    664
    author or copyright holder as a result of your choosing to follow a
    665
    later version.
    666
    
                                                    
                                                
    667
      15. Disclaimer of Warranty.
    668
    
                                                    
                                                
    669
      THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
    670
    APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
    671
    HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
    672
    OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
    673
    THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
    674
    PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
    675
    IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
    676
    ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
    677
    
                                                    
                                                
    678
      16. Limitation of Liability.
    679
    
                                                    
                                                
    680
      IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    681
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
    682
    THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
    683
    GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
    684
    USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
    685
    DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
    686
    PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
    687
    EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
    688
    SUCH DAMAGES.
    689
    
                                                    
                                                
    690
      17. Interpretation of Sections 15 and 16.
    691
    
                                                    
                                                
    692
      If the disclaimer of warranty and limitation of liability provided
    693
    above cannot be given local legal effect according to their terms,
    694
    reviewing courts shall apply local law that most closely approximates
    695
    an absolute waiver of all civil liability in connection with the
    696
    Program, unless a warranty or assumption of liability accompanies a
    697
    copy of the Program in return for a fee.
    698
    
                                                    
                                                
    699
                         END OF TERMS AND CONDITIONS
    700
    
                                                    
                                                
    701
                How to Apply These Terms to Your New Programs
    702
    
                                                    
                                                
    703
      If you develop a new program, and you want it to be of the greatest
    704
    possible use to the public, the best way to achieve this is to make it
    705
    free software which everyone can redistribute and change under these terms.
    706
    
                                                    
                                                
    707
      To do so, attach the following notices to the program.  It is safest
    708
    to attach them to the start of each source file to most effectively
    709
    state the exclusion of warranty; and each file should have at least
    710
    the "copyright" line and a pointer to where the full notice is found.
    711
    
                                                    
                                                
    712
        <one line to give the program's name and a brief idea of what it does.>
    713
        Copyright (C) <year>  <name of author>
    714
    
                                                    
                                                
    715
        This program is free software: you can redistribute it and/or modify
    716
        it under the terms of the GNU General Public License as published by
    717
        the Free Software Foundation, either version 3 of the License, or
    718
        (at your option) any later version.
    719
    
                                                    
                                                
    720
        This program is distributed in the hope that it will be useful,
    721
        but WITHOUT ANY WARRANTY; without even the implied warranty of
    722
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    723
        GNU General Public License for more details.
    724
    
                                                    
                                                
    725
        You should have received a copy of the GNU General Public License
    726
        along with this program.  If not, see <http://www.gnu.org/licenses/>.
    727
    
                                                    
                                                
    728
    Also add information on how to contact you by electronic and paper mail.
    729
    
                                                    
                                                
    730
      If the program does terminal interaction, make it output a short
    731
    notice like this when it starts in an interactive mode:
    732
    
                                                    
                                                
    733
        <program>  Copyright (C) <year>  <name of author>
    734
        This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    735
        This is free software, and you are welcome to redistribute it
    736
        under certain conditions; type `show c' for details.
    737
    
                                                    
                                                
    738
    The hypothetical commands `show w' and `show c' should show the appropriate
    739
    parts of the General Public License.  Of course, your program's commands
    740
    might be different; for a GUI interface, you would use an "about box".
    741
    
                                                    
                                                
    742
      You should also get your employer (if you work as a programmer) or school,
    743
    if any, to sign a "copyright disclaimer" for the program, if necessary.
    744
    For more information on this, and how to apply and follow the GNU GPL, see
    745
    <http://www.gnu.org/licenses/>.
    746
    
                                                    
                                                
    747
      The GNU General Public License does not permit incorporating your program
    748
    into proprietary programs.  If your program is a subroutine library, you
    749
    may consider it more useful to permit linking proprietary applications with
    750
    the library.  If this is what you want to do, use the GNU Lesser General
    751
    Public License instead of this License.  But first, please read
    752
    <http://www.gnu.org/philosophy/why-not-lgpl.html>.
    753
    
                                                    
                                                
    754
    */
    755
    
                                                    
                                                
    0.0% lib/forge-std/src/Base.sol
    Lines covered: 0 / 2 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    import {StdStorage} from "./StdStorage.sol";
    5
    import {Vm, VmSafe} from "./Vm.sol";
    6
    
                                                    
                                                
    7
    abstract contract CommonBase {
    8
        /// @dev Cheat code address.
    9
        /// Calculated as `address(uint160(uint256(keccak256("hevm cheat code"))))`.
    10
        address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;
    11
        /// @dev console.sol and console2.sol work by executing a staticcall to this address.
    12
        /// Calculated as `address(uint160(uint88(bytes11("console.log"))))`.
    13
        address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;
    14
        /// @dev Used when deploying with create2.
    15
        /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.
    16
        address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
    17
        /// @dev The default address for tx.origin and msg.sender.
    18
        /// Calculated as `address(uint160(uint256(keccak256("foundry default caller"))))`.
    19
        address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;
    20
        /// @dev The address of the first contract `CREATE`d by a running test contract.
    21
        /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.
    22
        /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.
    23
        address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;
    24
        /// @dev Deterministic deployment address of the Multicall3 contract.
    25
        /// Taken from https://www.multicall3.com.
    26
        address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;
    27
        /// @dev The order of the secp256k1 curve.
    28
        uint256 internal constant SECP256K1_ORDER =
    29
            115792089237316195423570985008687907852837564279074904382605163141518161494337;
    30
    
                                                    
                                                
    31
        uint256 internal constant UINT256_MAX =
    32
            115792089237316195423570985008687907853269984665640564039457584007913129639935;
    33
    
                                                    
                                                
    34
        Vm internal constant vm = Vm(VM_ADDRESS);
    35
        StdStorage internal stdstore;
    36
    }
    37
    
                                                    
                                                
    38
    abstract contract TestBase is CommonBase {}
    39
    
                                                    
                                                
    40
    abstract contract ScriptBase is CommonBase {
    41
        VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);
    42
    }
    43
    
                                                    
                                                
    0.0% lib/forge-std/src/Script.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    // 💬 ABOUT
    5
    // Forge Std's default Script.
    6
    
                                                    
                                                
    7
    // 🧩 MODULES
    8
    import {console} from "./console.sol";
    9
    import {console2} from "./console2.sol";
    10
    import {safeconsole} from "./safeconsole.sol";
    11
    import {StdChains} from "./StdChains.sol";
    12
    import {StdCheatsSafe} from "./StdCheats.sol";
    13
    import {StdConstants} from "./StdConstants.sol";
    14
    import {stdJson} from "./StdJson.sol";
    15
    import {stdMath} from "./StdMath.sol";
    16
    import {StdStorage, stdStorageSafe} from "./StdStorage.sol";
    17
    import {StdStyle} from "./StdStyle.sol";
    18
    import {StdUtils} from "./StdUtils.sol";
    19
    import {VmSafe} from "./Vm.sol";
    20
    
                                                    
                                                
    21
    // 📦 BOILERPLATE
    22
    import {ScriptBase} from "./Base.sol";
    23
    
                                                    
                                                
    24
    // ⭐️ SCRIPT
    25
    abstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {
    26
        // Note: IS_SCRIPT() must return true.
    27
        bool public IS_SCRIPT = true;
    28
    }
    29
    
                                                    
                                                
    0.0% lib/forge-std/src/StdAssertions.sol
    Lines covered: 0 / 9 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    pragma experimental ABIEncoderV2;
    4
    
                                                    
                                                
    5
    import {Vm} from "./Vm.sol";
    6
    
                                                    
                                                
    7
    abstract contract StdAssertions {
    8
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    9
    
                                                    
                                                
    10
        event log(string);
    11
        event logs(bytes);
    12
    
                                                    
                                                
    13
        event log_address(address);
    14
        event log_bytes32(bytes32);
    15
        event log_int(int256);
    16
        event log_uint(uint256);
    17
        event log_bytes(bytes);
    18
        event log_string(string);
    19
    
                                                    
                                                
    20
        event log_named_address(string key, address val);
    21
        event log_named_bytes32(string key, bytes32 val);
    22
        event log_named_decimal_int(string key, int256 val, uint256 decimals);
    23
        event log_named_decimal_uint(string key, uint256 val, uint256 decimals);
    24
        event log_named_int(string key, int256 val);
    25
        event log_named_uint(string key, uint256 val);
    26
        event log_named_bytes(string key, bytes val);
    27
        event log_named_string(string key, string val);
    28
    
                                                    
                                                
    29
        event log_array(uint256[] val);
    30
        event log_array(int256[] val);
    31
        event log_array(address[] val);
    32
        event log_named_array(string key, uint256[] val);
    33
        event log_named_array(string key, int256[] val);
    34
        event log_named_array(string key, address[] val);
    35
    
                                                    
                                                
    36
        bytes32 private constant FAILED_SLOT = bytes32("failed");
    37
    
                                                    
                                                
    38
        bool private _failed;
    39
    
                                                    
                                                
    40
        function failed() public view returns (bool) {
    41
            if (_failed) {
    42
                return true;
    43
            } else {
    44
                return vm.load(address(vm), FAILED_SLOT) != bytes32(0);
    45
            }
    46
        }
    47
    
                                                    
                                                
    48
        function fail() internal virtual {
    49
            vm.store(address(vm), FAILED_SLOT, bytes32(uint256(1)));
    50
            _failed = true;
    51
        }
    52
    
                                                    
                                                
    53
        function fail(string memory message) internal virtual {
    54
            fail();
    55
            vm.assertTrue(false, message);
    56
        }
    57
    
                                                    
                                                
    58
        function assertTrue(bool data) internal pure virtual {
    59
            if (!data) {
    60
                vm.assertTrue(data);
    61
            }
    62
        }
    63
    
                                                    
                                                
    64
        function assertTrue(bool data, string memory err) internal pure virtual {
    65
            if (!data) {
    66
                vm.assertTrue(data, err);
    67
            }
    68
        }
    69
    
                                                    
                                                
    70
        function assertFalse(bool data) internal pure virtual {
    71
            if (data) {
    72
                vm.assertFalse(data);
    73
            }
    74
        }
    75
    
                                                    
                                                
    76
        function assertFalse(bool data, string memory err) internal pure virtual {
    77
            if (data) {
    78
                vm.assertFalse(data, err);
    79
            }
    80
        }
    81
    
                                                    
                                                
    82
        function assertEq(bool left, bool right) internal pure virtual {
    83
            if (left != right) {
    84
                vm.assertEq(left, right);
    85
            }
    86
        }
    87
    
                                                    
                                                
    88
        function assertEq(bool left, bool right, string memory err) internal pure virtual {
    89
            if (left != right) {
    90
                vm.assertEq(left, right, err);
    91
            }
    92
        }
    93
    
                                                    
                                                
    94
        function assertEq(uint256 left, uint256 right) internal pure virtual {
    95
            if (left != right) {
    96
                vm.assertEq(left, right);
    97
            }
    98
        }
    99
    
                                                    
                                                
    100
        function assertEq(uint256 left, uint256 right, string memory err) internal pure virtual {
    101
            if (left != right) {
    102
                vm.assertEq(left, right, err);
    103
            }
    104
        }
    105
    
                                                    
                                                
    106
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    107
            vm.assertEqDecimal(left, right, decimals);
    108
        }
    109
    
                                                    
                                                
    110
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    111
            vm.assertEqDecimal(left, right, decimals, err);
    112
        }
    113
    
                                                    
                                                
    114
        function assertEq(int256 left, int256 right) internal pure virtual {
    115
            if (left != right) {
    116
                vm.assertEq(left, right);
    117
            }
    118
        }
    119
    
                                                    
                                                
    120
        function assertEq(int256 left, int256 right, string memory err) internal pure virtual {
    121
            if (left != right) {
    122
                vm.assertEq(left, right, err);
    123
            }
    124
        }
    125
    
                                                    
                                                
    126
        function assertEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    127
            vm.assertEqDecimal(left, right, decimals);
    128
        }
    129
    
                                                    
                                                
    130
        function assertEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    131
            vm.assertEqDecimal(left, right, decimals, err);
    132
        }
    133
    
                                                    
                                                
    134
        function assertEq(address left, address right) internal pure virtual {
    135
            if (left != right) {
    136
                vm.assertEq(left, right);
    137
            }
    138
        }
    139
    
                                                    
                                                
    140
        function assertEq(address left, address right, string memory err) internal pure virtual {
    141
            if (left != right) {
    142
                vm.assertEq(left, right, err);
    143
            }
    144
        }
    145
    
                                                    
                                                
    146
        function assertEq(bytes32 left, bytes32 right) internal pure virtual {
    147
            if (left != right) {
    148
                vm.assertEq(left, right);
    149
            }
    150
        }
    151
    
                                                    
                                                
    152
        function assertEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    153
            if (left != right) {
    154
                vm.assertEq(left, right, err);
    155
            }
    156
        }
    157
    
                                                    
                                                
    158
        function assertEq32(bytes32 left, bytes32 right) internal pure virtual {
    159
            if (left != right) {
    160
                vm.assertEq(left, right);
    161
            }
    162
        }
    163
    
                                                    
                                                
    164
        function assertEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    165
            if (left != right) {
    166
                vm.assertEq(left, right, err);
    167
            }
    168
        }
    169
    
                                                    
                                                
    170
        function assertEq(string memory left, string memory right) internal pure virtual {
    171
            vm.assertEq(left, right);
    172
        }
    173
    
                                                    
                                                
    174
        function assertEq(string memory left, string memory right, string memory err) internal pure virtual {
    175
            vm.assertEq(left, right, err);
    176
        }
    177
    
                                                    
                                                
    178
        function assertEq(bytes memory left, bytes memory right) internal pure virtual {
    179
            vm.assertEq(left, right);
    180
        }
    181
    
                                                    
                                                
    182
        function assertEq(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    183
            vm.assertEq(left, right, err);
    184
        }
    185
    
                                                    
                                                
    186
        function assertEq(bool[] memory left, bool[] memory right) internal pure virtual {
    187
            vm.assertEq(left, right);
    188
        }
    189
    
                                                    
                                                
    190
        function assertEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual {
    191
            vm.assertEq(left, right, err);
    192
        }
    193
    
                                                    
                                                
    194
        function assertEq(uint256[] memory left, uint256[] memory right) internal pure virtual {
    195
            vm.assertEq(left, right);
    196
        }
    197
    
                                                    
                                                
    198
        function assertEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual {
    199
            vm.assertEq(left, right, err);
    200
        }
    201
    
                                                    
                                                
    202
        function assertEq(int256[] memory left, int256[] memory right) internal pure virtual {
    203
            vm.assertEq(left, right);
    204
        }
    205
    
                                                    
                                                
    206
        function assertEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual {
    207
            vm.assertEq(left, right, err);
    208
        }
    209
    
                                                    
                                                
    210
        function assertEq(address[] memory left, address[] memory right) internal pure virtual {
    211
            vm.assertEq(left, right);
    212
        }
    213
    
                                                    
                                                
    214
        function assertEq(address[] memory left, address[] memory right, string memory err) internal pure virtual {
    215
            vm.assertEq(left, right, err);
    216
        }
    217
    
                                                    
                                                
    218
        function assertEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual {
    219
            vm.assertEq(left, right);
    220
        }
    221
    
                                                    
                                                
    222
        function assertEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual {
    223
            vm.assertEq(left, right, err);
    224
        }
    225
    
                                                    
                                                
    226
        function assertEq(string[] memory left, string[] memory right) internal pure virtual {
    227
            vm.assertEq(left, right);
    228
        }
    229
    
                                                    
                                                
    230
        function assertEq(string[] memory left, string[] memory right, string memory err) internal pure virtual {
    231
            vm.assertEq(left, right, err);
    232
        }
    233
    
                                                    
                                                
    234
        function assertEq(bytes[] memory left, bytes[] memory right) internal pure virtual {
    235
            vm.assertEq(left, right);
    236
        }
    237
    
                                                    
                                                
    238
        function assertEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual {
    239
            vm.assertEq(left, right, err);
    240
        }
    241
    
                                                    
                                                
    242
        // Legacy helper
    243
        function assertEqUint(uint256 left, uint256 right) internal pure virtual {
    244
            assertEq(left, right);
    245
        }
    246
    
                                                    
                                                
    247
        function assertNotEq(bool left, bool right) internal pure virtual {
    248
            if (left == right) {
    249
                vm.assertNotEq(left, right);
    250
            }
    251
        }
    252
    
                                                    
                                                
    253
        function assertNotEq(bool left, bool right, string memory err) internal pure virtual {
    254
            if (left == right) {
    255
                vm.assertNotEq(left, right, err);
    256
            }
    257
        }
    258
    
                                                    
                                                
    259
        function assertNotEq(uint256 left, uint256 right) internal pure virtual {
    260
            if (left == right) {
    261
                vm.assertNotEq(left, right);
    262
            }
    263
        }
    264
    
                                                    
                                                
    265
        function assertNotEq(uint256 left, uint256 right, string memory err) internal pure virtual {
    266
            if (left == right) {
    267
                vm.assertNotEq(left, right, err);
    268
            }
    269
        }
    270
    
                                                    
                                                
    271
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    272
            vm.assertNotEqDecimal(left, right, decimals);
    273
        }
    274
    
                                                    
                                                
    275
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err)
    276
            internal
    277
            pure
    278
            virtual
    279
        {
    280
            vm.assertNotEqDecimal(left, right, decimals, err);
    281
        }
    282
    
                                                    
                                                
    283
        function assertNotEq(int256 left, int256 right) internal pure virtual {
    284
            if (left == right) {
    285
                vm.assertNotEq(left, right);
    286
            }
    287
        }
    288
    
                                                    
                                                
    289
        function assertNotEq(int256 left, int256 right, string memory err) internal pure virtual {
    290
            if (left == right) {
    291
                vm.assertNotEq(left, right, err);
    292
            }
    293
        }
    294
    
                                                    
                                                
    295
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    296
            vm.assertNotEqDecimal(left, right, decimals);
    297
        }
    298
    
                                                    
                                                
    299
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    300
            vm.assertNotEqDecimal(left, right, decimals, err);
    301
        }
    302
    
                                                    
                                                
    303
        function assertNotEq(address left, address right) internal pure virtual {
    304
            if (left == right) {
    305
                vm.assertNotEq(left, right);
    306
            }
    307
        }
    308
    
                                                    
                                                
    309
        function assertNotEq(address left, address right, string memory err) internal pure virtual {
    310
            if (left == right) {
    311
                vm.assertNotEq(left, right, err);
    312
            }
    313
        }
    314
    
                                                    
                                                
    315
        function assertNotEq(bytes32 left, bytes32 right) internal pure virtual {
    316
            if (left == right) {
    317
                vm.assertNotEq(left, right);
    318
            }
    319
        }
    320
    
                                                    
                                                
    321
        function assertNotEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    322
            if (left == right) {
    323
                vm.assertNotEq(left, right, err);
    324
            }
    325
        }
    326
    
                                                    
                                                
    327
        function assertNotEq32(bytes32 left, bytes32 right) internal pure virtual {
    328
            if (left == right) {
    329
                vm.assertNotEq(left, right);
    330
            }
    331
        }
    332
    
                                                    
                                                
    333
        function assertNotEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    334
            if (left == right) {
    335
                vm.assertNotEq(left, right, err);
    336
            }
    337
        }
    338
    
                                                    
                                                
    339
        function assertNotEq(string memory left, string memory right) internal pure virtual {
    340
            vm.assertNotEq(left, right);
    341
        }
    342
    
                                                    
                                                
    343
        function assertNotEq(string memory left, string memory right, string memory err) internal pure virtual {
    344
            vm.assertNotEq(left, right, err);
    345
        }
    346
    
                                                    
                                                
    347
        function assertNotEq(bytes memory left, bytes memory right) internal pure virtual {
    348
            vm.assertNotEq(left, right);
    349
        }
    350
    
                                                    
                                                
    351
        function assertNotEq(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    352
            vm.assertNotEq(left, right, err);
    353
        }
    354
    
                                                    
                                                
    355
        function assertNotEq(bool[] memory left, bool[] memory right) internal pure virtual {
    356
            vm.assertNotEq(left, right);
    357
        }
    358
    
                                                    
                                                
    359
        function assertNotEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual {
    360
            vm.assertNotEq(left, right, err);
    361
        }
    362
    
                                                    
                                                
    363
        function assertNotEq(uint256[] memory left, uint256[] memory right) internal pure virtual {
    364
            vm.assertNotEq(left, right);
    365
        }
    366
    
                                                    
                                                
    367
        function assertNotEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual {
    368
            vm.assertNotEq(left, right, err);
    369
        }
    370
    
                                                    
                                                
    371
        function assertNotEq(int256[] memory left, int256[] memory right) internal pure virtual {
    372
            vm.assertNotEq(left, right);
    373
        }
    374
    
                                                    
                                                
    375
        function assertNotEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual {
    376
            vm.assertNotEq(left, right, err);
    377
        }
    378
    
                                                    
                                                
    379
        function assertNotEq(address[] memory left, address[] memory right) internal pure virtual {
    380
            vm.assertNotEq(left, right);
    381
        }
    382
    
                                                    
                                                
    383
        function assertNotEq(address[] memory left, address[] memory right, string memory err) internal pure virtual {
    384
            vm.assertNotEq(left, right, err);
    385
        }
    386
    
                                                    
                                                
    387
        function assertNotEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual {
    388
            vm.assertNotEq(left, right);
    389
        }
    390
    
                                                    
                                                
    391
        function assertNotEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual {
    392
            vm.assertNotEq(left, right, err);
    393
        }
    394
    
                                                    
                                                
    395
        function assertNotEq(string[] memory left, string[] memory right) internal pure virtual {
    396
            vm.assertNotEq(left, right);
    397
        }
    398
    
                                                    
                                                
    399
        function assertNotEq(string[] memory left, string[] memory right, string memory err) internal pure virtual {
    400
            vm.assertNotEq(left, right, err);
    401
        }
    402
    
                                                    
                                                
    403
        function assertNotEq(bytes[] memory left, bytes[] memory right) internal pure virtual {
    404
            vm.assertNotEq(left, right);
    405
        }
    406
    
                                                    
                                                
    407
        function assertNotEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual {
    408
            vm.assertNotEq(left, right, err);
    409
        }
    410
    
                                                    
                                                
    411
        function assertLt(uint256 left, uint256 right) internal pure virtual {
    412
            if (left >= right) {
    413
                vm.assertLt(left, right);
    414
            }
    415
        }
    416
    
                                                    
                                                
    417
        function assertLt(uint256 left, uint256 right, string memory err) internal pure virtual {
    418
            if (left >= right) {
    419
                vm.assertLt(left, right, err);
    420
            }
    421
        }
    422
    
                                                    
                                                
    423
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    424
            vm.assertLtDecimal(left, right, decimals);
    425
        }
    426
    
                                                    
                                                
    427
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    428
            vm.assertLtDecimal(left, right, decimals, err);
    429
        }
    430
    
                                                    
                                                
    431
        function assertLt(int256 left, int256 right) internal pure virtual {
    432
            if (left >= right) {
    433
                vm.assertLt(left, right);
    434
            }
    435
        }
    436
    
                                                    
                                                
    437
        function assertLt(int256 left, int256 right, string memory err) internal pure virtual {
    438
            if (left >= right) {
    439
                vm.assertLt(left, right, err);
    440
            }
    441
        }
    442
    
                                                    
                                                
    443
        function assertLtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    444
            vm.assertLtDecimal(left, right, decimals);
    445
        }
    446
    
                                                    
                                                
    447
        function assertLtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    448
            vm.assertLtDecimal(left, right, decimals, err);
    449
        }
    450
    
                                                    
                                                
    451
        function assertGt(uint256 left, uint256 right) internal pure virtual {
    452
            if (left <= right) {
    453
                vm.assertGt(left, right);
    454
            }
    455
        }
    456
    
                                                    
                                                
    457
        function assertGt(uint256 left, uint256 right, string memory err) internal pure virtual {
    458
            if (left <= right) {
    459
                vm.assertGt(left, right, err);
    460
            }
    461
        }
    462
    
                                                    
                                                
    463
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    464
            vm.assertGtDecimal(left, right, decimals);
    465
        }
    466
    
                                                    
                                                
    467
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    468
            vm.assertGtDecimal(left, right, decimals, err);
    469
        }
    470
    
                                                    
                                                
    471
        function assertGt(int256 left, int256 right) internal pure virtual {
    472
            if (left <= right) {
    473
                vm.assertGt(left, right);
    474
            }
    475
        }
    476
    
                                                    
                                                
    477
        function assertGt(int256 left, int256 right, string memory err) internal pure virtual {
    478
            if (left <= right) {
    479
                vm.assertGt(left, right, err);
    480
            }
    481
        }
    482
    
                                                    
                                                
    483
        function assertGtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    484
            vm.assertGtDecimal(left, right, decimals);
    485
        }
    486
    
                                                    
                                                
    487
        function assertGtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    488
            vm.assertGtDecimal(left, right, decimals, err);
    489
        }
    490
    
                                                    
                                                
    491
        function assertLe(uint256 left, uint256 right) internal pure virtual {
    492
            if (left > right) {
    493
                vm.assertLe(left, right);
    494
            }
    495
        }
    496
    
                                                    
                                                
    497
        function assertLe(uint256 left, uint256 right, string memory err) internal pure virtual {
    498
            if (left > right) {
    499
                vm.assertLe(left, right, err);
    500
            }
    501
        }
    502
    
                                                    
                                                
    503
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    504
            vm.assertLeDecimal(left, right, decimals);
    505
        }
    506
    
                                                    
                                                
    507
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    508
            vm.assertLeDecimal(left, right, decimals, err);
    509
        }
    510
    
                                                    
                                                
    511
        function assertLe(int256 left, int256 right) internal pure virtual {
    512
            if (left > right) {
    513
                vm.assertLe(left, right);
    514
            }
    515
        }
    516
    
                                                    
                                                
    517
        function assertLe(int256 left, int256 right, string memory err) internal pure virtual {
    518
            if (left > right) {
    519
                vm.assertLe(left, right, err);
    520
            }
    521
        }
    522
    
                                                    
                                                
    523
        function assertLeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    524
            vm.assertLeDecimal(left, right, decimals);
    525
        }
    526
    
                                                    
                                                
    527
        function assertLeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    528
            vm.assertLeDecimal(left, right, decimals, err);
    529
        }
    530
    
                                                    
                                                
    531
        function assertGe(uint256 left, uint256 right) internal pure virtual {
    532
            if (left < right) {
    533
                vm.assertGe(left, right);
    534
            }
    535
        }
    536
    
                                                    
                                                
    537
        function assertGe(uint256 left, uint256 right, string memory err) internal pure virtual {
    538
            if (left < right) {
    539
                vm.assertGe(left, right, err);
    540
            }
    541
        }
    542
    
                                                    
                                                
    543
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    544
            vm.assertGeDecimal(left, right, decimals);
    545
        }
    546
    
                                                    
                                                
    547
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    548
            vm.assertGeDecimal(left, right, decimals, err);
    549
        }
    550
    
                                                    
                                                
    551
        function assertGe(int256 left, int256 right) internal pure virtual {
    552
            if (left < right) {
    553
                vm.assertGe(left, right);
    554
            }
    555
        }
    556
    
                                                    
                                                
    557
        function assertGe(int256 left, int256 right, string memory err) internal pure virtual {
    558
            if (left < right) {
    559
                vm.assertGe(left, right, err);
    560
            }
    561
        }
    562
    
                                                    
                                                
    563
        function assertGeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    564
            vm.assertGeDecimal(left, right, decimals);
    565
        }
    566
    
                                                    
                                                
    567
        function assertGeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    568
            vm.assertGeDecimal(left, right, decimals, err);
    569
        }
    570
    
                                                    
                                                
    571
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) internal pure virtual {
    572
            vm.assertApproxEqAbs(left, right, maxDelta);
    573
        }
    574
    
                                                    
                                                
    575
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string memory err)
    576
            internal
    577
            pure
    578
            virtual
    579
        {
    580
            vm.assertApproxEqAbs(left, right, maxDelta, err);
    581
        }
    582
    
                                                    
                                                
    583
        function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals)
    584
            internal
    585
            pure
    586
            virtual
    587
        {
    588
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals);
    589
        }
    590
    
                                                    
                                                
    591
        function assertApproxEqAbsDecimal(
    592
            uint256 left,
    593
            uint256 right,
    594
            uint256 maxDelta,
    595
            uint256 decimals,
    596
            string memory err
    597
        ) internal pure virtual {
    598
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err);
    599
        }
    600
    
                                                    
                                                
    601
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) internal pure virtual {
    602
            vm.assertApproxEqAbs(left, right, maxDelta);
    603
        }
    604
    
                                                    
                                                
    605
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string memory err) internal pure virtual {
    606
            vm.assertApproxEqAbs(left, right, maxDelta, err);
    607
        }
    608
    
                                                    
                                                
    609
        function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals)
    610
            internal
    611
            pure
    612
            virtual
    613
        {
    614
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals);
    615
        }
    616
    
                                                    
                                                
    617
        function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string memory err)
    618
            internal
    619
            pure
    620
            virtual
    621
        {
    622
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err);
    623
        }
    624
    
                                                    
                                                
    625
        function assertApproxEqRel(
    626
            uint256 left,
    627
            uint256 right,
    628
            uint256 maxPercentDelta // An 18 decimal fixed point number, where 1e18 == 100%
    629
        ) internal pure virtual {
    630
            vm.assertApproxEqRel(left, right, maxPercentDelta);
    631
        }
    632
    
                                                    
                                                
    633
        function assertApproxEqRel(
    634
            uint256 left,
    635
            uint256 right,
    636
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    637
            string memory err
    638
        ) internal pure virtual {
    639
            vm.assertApproxEqRel(left, right, maxPercentDelta, err);
    640
        }
    641
    
                                                    
                                                
    642
        function assertApproxEqRelDecimal(
    643
            uint256 left,
    644
            uint256 right,
    645
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    646
            uint256 decimals
    647
        ) internal pure virtual {
    648
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals);
    649
        }
    650
    
                                                    
                                                
    651
        function assertApproxEqRelDecimal(
    652
            uint256 left,
    653
            uint256 right,
    654
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    655
            uint256 decimals,
    656
            string memory err
    657
        ) internal pure virtual {
    658
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err);
    659
        }
    660
    
                                                    
                                                
    661
        function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) internal pure virtual {
    662
            vm.assertApproxEqRel(left, right, maxPercentDelta);
    663
        }
    664
    
                                                    
                                                
    665
        function assertApproxEqRel(
    666
            int256 left,
    667
            int256 right,
    668
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    669
            string memory err
    670
        ) internal pure virtual {
    671
            vm.assertApproxEqRel(left, right, maxPercentDelta, err);
    672
        }
    673
    
                                                    
                                                
    674
        function assertApproxEqRelDecimal(
    675
            int256 left,
    676
            int256 right,
    677
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    678
            uint256 decimals
    679
        ) internal pure virtual {
    680
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals);
    681
        }
    682
    
                                                    
                                                
    683
        function assertApproxEqRelDecimal(
    684
            int256 left,
    685
            int256 right,
    686
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    687
            uint256 decimals,
    688
            string memory err
    689
        ) internal pure virtual {
    690
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err);
    691
        }
    692
    
                                                    
                                                
    693
        // Inherited from DSTest, not used but kept for backwards-compatibility
    694
        function checkEq0(bytes memory left, bytes memory right) internal pure returns (bool) {
    695
            return keccak256(left) == keccak256(right);
    696
        }
    697
    
                                                    
                                                
    698
        function assertEq0(bytes memory left, bytes memory right) internal pure virtual {
    699
            assertEq(left, right);
    700
        }
    701
    
                                                    
                                                
    702
        function assertEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    703
            assertEq(left, right, err);
    704
        }
    705
    
                                                    
                                                
    706
        function assertNotEq0(bytes memory left, bytes memory right) internal pure virtual {
    707
            assertNotEq(left, right);
    708
        }
    709
    
                                                    
                                                
    710
        function assertNotEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    711
            assertNotEq(left, right, err);
    712
        }
    713
    
                                                    
                                                
    714
        function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB) internal virtual {
    715
            assertEqCall(target, callDataA, target, callDataB, true);
    716
        }
    717
    
                                                    
                                                
    718
        function assertEqCall(address targetA, bytes memory callDataA, address targetB, bytes memory callDataB)
    719
            internal
    720
            virtual
    721
        {
    722
            assertEqCall(targetA, callDataA, targetB, callDataB, true);
    723
        }
    724
    
                                                    
                                                
    725
        function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB, bool strictRevertData)
    726
            internal
    727
            virtual
    728
        {
    729
            assertEqCall(target, callDataA, target, callDataB, strictRevertData);
    730
        }
    731
    
                                                    
                                                
    732
        function assertEqCall(
    733
            address targetA,
    734
            bytes memory callDataA,
    735
            address targetB,
    736
            bytes memory callDataB,
    737
            bool strictRevertData
    738
        ) internal virtual {
    739
            (bool successA, bytes memory returnDataA) = address(targetA).call(callDataA);
    740
            (bool successB, bytes memory returnDataB) = address(targetB).call(callDataB);
    741
    
                                                    
                                                
    742
            if (successA && successB) {
    743
                assertEq(returnDataA, returnDataB, "Call return data does not match");
    744
            }
    745
    
                                                    
                                                
    746
            if (!successA && !successB && strictRevertData) {
    747
                assertEq(returnDataA, returnDataB, "Call revert data does not match");
    748
            }
    749
    
                                                    
                                                
    750
            if (!successA && successB) {
    751
                emit log("Error: Calls were not equal");
    752
                emit log_named_bytes("  Left call revert data", returnDataA);
    753
                emit log_named_bytes(" Right call return data", returnDataB);
    754
                revert("assertion failed");
    755
            }
    756
    
                                                    
                                                
    757
            if (successA && !successB) {
    758
                emit log("Error: Calls were not equal");
    759
                emit log_named_bytes("  Left call return data", returnDataA);
    760
                emit log_named_bytes(" Right call revert data", returnDataB);
    761
                revert("assertion failed");
    762
            }
    763
        }
    764
    }
    765
    
                                                    
                                                
    0.0% lib/forge-std/src/StdChains.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    import {VmSafe} from "./Vm.sol";
    5
    
                                                    
                                                
    6
    /**
    7
     * StdChains provides information about EVM compatible chains that can be used in scripts/tests.
    8
     * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are
    9
     * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of
    10
     * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the
    11
     * alias used in this contract, which can be found as the first argument to the
    12
     * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.
    13
     *
    14
     * There are two main ways to use this contract:
    15
     *   1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or
    16
     *      `setChain(string memory chainAlias, Chain memory chain)`
    17
     *   2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.
    18
     *
    19
     * The first time either of those are used, chains are initialized with the default set of RPC URLs.
    20
     * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in
    21
     * `defaultRpcUrls`.
    22
     *
    23
     * The `setChain` function is straightforward, and it simply saves off the given chain data.
    24
     *
    25
     * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say
    26
     * we want to retrieve the RPC URL for `mainnet`:
    27
     *   - If you have specified data with `setChain`, it will return that.
    28
     *   - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it
    29
     *     is valid (e.g. a URL is specified, or an environment variable is given and exists).
    30
     *   - If neither of the above conditions is met, the default data is returned.
    31
     *
    32
     * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.
    33
     */
    34
    abstract contract StdChains {
    35
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    36
    
                                                    
                                                
    37
        bool private stdChainsInitialized;
    38
    
                                                    
                                                
    39
        struct ChainData {
    40
            string name;
    41
            uint256 chainId;
    42
            string rpcUrl;
    43
        }
    44
    
                                                    
                                                
    45
        struct Chain {
    46
            // The chain name.
    47
            string name;
    48
            // The chain's Chain ID.
    49
            uint256 chainId;
    50
            // The chain's alias. (i.e. what gets specified in `foundry.toml`).
    51
            string chainAlias;
    52
            // A default RPC endpoint for this chain.
    53
            // NOTE: This default RPC URL is included for convenience to facilitate quick tests and
    54
            // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy
    55
            // usage as you will be throttled and this is a disservice to others who need this endpoint.
    56
            string rpcUrl;
    57
        }
    58
    
                                                    
                                                
    59
        // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.
    60
        mapping(string => Chain) private chains;
    61
        // Maps from the chain's alias to it's default RPC URL.
    62
        mapping(string => string) private defaultRpcUrls;
    63
        // Maps from a chain ID to it's alias.
    64
        mapping(uint256 => string) private idToAlias;
    65
    
                                                    
                                                
    66
        bool private fallbackToDefaultRpcUrls = true;
    67
    
                                                    
                                                
    68
        // The RPC URL will be fetched from config or defaultRpcUrls if possible.
    69
        function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {
    70
            require(bytes(chainAlias).length != 0, "StdChains getChain(string): Chain alias cannot be the empty string.");
    71
    
                                                    
                                                
    72
            initializeStdChains();
    73
            chain = chains[chainAlias];
    74
            require(
    75
                chain.chainId != 0,
    76
                string(abi.encodePacked("StdChains getChain(string): Chain with alias \"", chainAlias, "\" not found."))
    77
            );
    78
    
                                                    
                                                
    79
            chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
    80
        }
    81
    
                                                    
                                                
    82
        function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {
    83
            require(chainId != 0, "StdChains getChain(uint256): Chain ID cannot be 0.");
    84
            initializeStdChains();
    85
            string memory chainAlias = idToAlias[chainId];
    86
    
                                                    
                                                
    87
            chain = chains[chainAlias];
    88
    
                                                    
                                                
    89
            require(
    90
                chain.chainId != 0,
    91
                string(abi.encodePacked("StdChains getChain(uint256): Chain with ID ", vm.toString(chainId), " not found."))
    92
            );
    93
    
                                                    
                                                
    94
            chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
    95
        }
    96
    
                                                    
                                                
    97
        // set chain info, with priority to argument's rpcUrl field.
    98
        function setChain(string memory chainAlias, ChainData memory chain) internal virtual {
    99
            require(
    100
                bytes(chainAlias).length != 0,
    101
                "StdChains setChain(string,ChainData): Chain alias cannot be the empty string."
    102
            );
    103
    
                                                    
                                                
    104
            require(chain.chainId != 0, "StdChains setChain(string,ChainData): Chain ID cannot be 0.");
    105
    
                                                    
                                                
    106
            initializeStdChains();
    107
            string memory foundAlias = idToAlias[chain.chainId];
    108
    
                                                    
                                                
    109
            require(
    110
                bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),
    111
                string(
    112
                    abi.encodePacked(
    113
                        "StdChains setChain(string,ChainData): Chain ID ",
    114
                        vm.toString(chain.chainId),
    115
                        " already used by \"",
    116
                        foundAlias,
    117
                        "\"."
    118
                    )
    119
                )
    120
            );
    121
    
                                                    
                                                
    122
            uint256 oldChainId = chains[chainAlias].chainId;
    123
            delete idToAlias[oldChainId];
    124
    
                                                    
                                                
    125
            chains[chainAlias] =
    126
                Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});
    127
            idToAlias[chain.chainId] = chainAlias;
    128
        }
    129
    
                                                    
                                                
    130
        // set chain info, with priority to argument's rpcUrl field.
    131
        function setChain(string memory chainAlias, Chain memory chain) internal virtual {
    132
            setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));
    133
        }
    134
    
                                                    
                                                
    135
        function _toUpper(string memory str) private pure returns (string memory) {
    136
            bytes memory strb = bytes(str);
    137
            bytes memory copy = new bytes(strb.length);
    138
            for (uint256 i = 0; i < strb.length; i++) {
    139
                bytes1 b = strb[i];
    140
                if (b >= 0x61 && b <= 0x7A) {
    141
                    copy[i] = bytes1(uint8(b) - 32);
    142
                } else {
    143
                    copy[i] = b;
    144
                }
    145
            }
    146
            return string(copy);
    147
        }
    148
    
                                                    
                                                
    149
        // lookup rpcUrl, in descending order of priority:
    150
        // current -> config (foundry.toml) -> environment variable -> default
    151
        function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)
    152
            private
    153
            view
    154
            returns (Chain memory)
    155
        {
    156
            if (bytes(chain.rpcUrl).length == 0) {
    157
                try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {
    158
                    chain.rpcUrl = configRpcUrl;
    159
                } catch (bytes memory err) {
    160
                    string memory envName = string(abi.encodePacked(_toUpper(chainAlias), "_RPC_URL"));
    161
                    if (fallbackToDefaultRpcUrls) {
    162
                        chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);
    163
                    } else {
    164
                        chain.rpcUrl = vm.envString(envName);
    165
                    }
    166
                    // Distinguish 'not found' from 'cannot read'
    167
                    // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions
    168
                    bytes memory oldNotFoundError =
    169
                        abi.encodeWithSignature("CheatCodeError", string(abi.encodePacked("invalid rpc url ", chainAlias)));
    170
                    bytes memory newNotFoundError = abi.encodeWithSignature(
    171
                        "CheatcodeError(string)", string(abi.encodePacked("invalid rpc url: ", chainAlias))
    172
                    );
    173
                    bytes32 errHash = keccak256(err);
    174
                    if (
    175
                        (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))
    176
                            || bytes(chain.rpcUrl).length == 0
    177
                    ) {
    178
                        /// @solidity memory-safe-assembly
    179
                        assembly {
    180
                            revert(add(32, err), mload(err))
    181
                        }
    182
                    }
    183
                }
    184
            }
    185
            return chain;
    186
        }
    187
    
                                                    
                                                
    188
        function setFallbackToDefaultRpcUrls(bool useDefault) internal {
    189
            fallbackToDefaultRpcUrls = useDefault;
    190
        }
    191
    
                                                    
                                                
    192
        function initializeStdChains() private {
    193
            if (stdChainsInitialized) return;
    194
    
                                                    
                                                
    195
            stdChainsInitialized = true;
    196
    
                                                    
                                                
    197
            // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`
    198
            setChainWithDefaultRpcUrl("anvil", ChainData("Anvil", 31337, "http://127.0.0.1:8545"));
    199
            setChainWithDefaultRpcUrl("mainnet", ChainData("Mainnet", 1, "https://eth.llamarpc.com"));
    200
            setChainWithDefaultRpcUrl(
    201
                "sepolia", ChainData("Sepolia", 11155111, "https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001")
    202
            );
    203
            setChainWithDefaultRpcUrl("holesky", ChainData("Holesky", 17000, "https://rpc.holesky.ethpandaops.io"));
    204
            setChainWithDefaultRpcUrl("hoodi", ChainData("Hoodi", 560048, "https://rpc.hoodi.ethpandaops.io"));
    205
            setChainWithDefaultRpcUrl("optimism", ChainData("Optimism", 10, "https://mainnet.optimism.io"));
    206
            setChainWithDefaultRpcUrl(
    207
                "optimism_sepolia", ChainData("Optimism Sepolia", 11155420, "https://sepolia.optimism.io")
    208
            );
    209
            setChainWithDefaultRpcUrl("arbitrum_one", ChainData("Arbitrum One", 42161, "https://arb1.arbitrum.io/rpc"));
    210
            setChainWithDefaultRpcUrl(
    211
                "arbitrum_one_sepolia", ChainData("Arbitrum One Sepolia", 421614, "https://sepolia-rollup.arbitrum.io/rpc")
    212
            );
    213
            setChainWithDefaultRpcUrl("arbitrum_nova", ChainData("Arbitrum Nova", 42170, "https://nova.arbitrum.io/rpc"));
    214
            setChainWithDefaultRpcUrl("polygon", ChainData("Polygon", 137, "https://polygon-rpc.com"));
    215
            setChainWithDefaultRpcUrl(
    216
                "polygon_amoy", ChainData("Polygon Amoy", 80002, "https://rpc-amoy.polygon.technology")
    217
            );
    218
            setChainWithDefaultRpcUrl("avalanche", ChainData("Avalanche", 43114, "https://api.avax.network/ext/bc/C/rpc"));
    219
            setChainWithDefaultRpcUrl(
    220
                "avalanche_fuji", ChainData("Avalanche Fuji", 43113, "https://api.avax-test.network/ext/bc/C/rpc")
    221
            );
    222
            setChainWithDefaultRpcUrl(
    223
                "bnb_smart_chain", ChainData("BNB Smart Chain", 56, "https://bsc-dataseed1.binance.org")
    224
            );
    225
            setChainWithDefaultRpcUrl(
    226
                "bnb_smart_chain_testnet",
    227
                ChainData("BNB Smart Chain Testnet", 97, "https://rpc.ankr.com/bsc_testnet_chapel")
    228
            );
    229
            setChainWithDefaultRpcUrl("gnosis_chain", ChainData("Gnosis Chain", 100, "https://rpc.gnosischain.com"));
    230
            setChainWithDefaultRpcUrl("moonbeam", ChainData("Moonbeam", 1284, "https://rpc.api.moonbeam.network"));
    231
            setChainWithDefaultRpcUrl(
    232
                "moonriver", ChainData("Moonriver", 1285, "https://rpc.api.moonriver.moonbeam.network")
    233
            );
    234
            setChainWithDefaultRpcUrl("moonbase", ChainData("Moonbase", 1287, "https://rpc.testnet.moonbeam.network"));
    235
            setChainWithDefaultRpcUrl("base_sepolia", ChainData("Base Sepolia", 84532, "https://sepolia.base.org"));
    236
            setChainWithDefaultRpcUrl("base", ChainData("Base", 8453, "https://mainnet.base.org"));
    237
            setChainWithDefaultRpcUrl("blast_sepolia", ChainData("Blast Sepolia", 168587773, "https://sepolia.blast.io"));
    238
            setChainWithDefaultRpcUrl("blast", ChainData("Blast", 81457, "https://rpc.blast.io"));
    239
            setChainWithDefaultRpcUrl("fantom_opera", ChainData("Fantom Opera", 250, "https://rpc.ankr.com/fantom/"));
    240
            setChainWithDefaultRpcUrl(
    241
                "fantom_opera_testnet", ChainData("Fantom Opera Testnet", 4002, "https://rpc.ankr.com/fantom_testnet/")
    242
            );
    243
            setChainWithDefaultRpcUrl("fraxtal", ChainData("Fraxtal", 252, "https://rpc.frax.com"));
    244
            setChainWithDefaultRpcUrl("fraxtal_testnet", ChainData("Fraxtal Testnet", 2522, "https://rpc.testnet.frax.com"));
    245
            setChainWithDefaultRpcUrl(
    246
                "berachain_bartio_testnet", ChainData("Berachain bArtio Testnet", 80084, "https://bartio.rpc.berachain.com")
    247
            );
    248
            setChainWithDefaultRpcUrl("flare", ChainData("Flare", 14, "https://flare-api.flare.network/ext/C/rpc"));
    249
            setChainWithDefaultRpcUrl(
    250
                "flare_coston2", ChainData("Flare Coston2", 114, "https://coston2-api.flare.network/ext/C/rpc")
    251
            );
    252
    
                                                    
                                                
    253
            setChainWithDefaultRpcUrl("mode", ChainData("Mode", 34443, "https://mode.drpc.org"));
    254
            setChainWithDefaultRpcUrl("mode_sepolia", ChainData("Mode Sepolia", 919, "https://sepolia.mode.network"));
    255
    
                                                    
                                                
    256
            setChainWithDefaultRpcUrl("zora", ChainData("Zora", 7777777, "https://zora.drpc.org"));
    257
            setChainWithDefaultRpcUrl(
    258
                "zora_sepolia", ChainData("Zora Sepolia", 999999999, "https://sepolia.rpc.zora.energy")
    259
            );
    260
    
                                                    
                                                
    261
            setChainWithDefaultRpcUrl("race", ChainData("Race", 6805, "https://racemainnet.io"));
    262
            setChainWithDefaultRpcUrl("race_sepolia", ChainData("Race Sepolia", 6806, "https://racemainnet.io"));
    263
    
                                                    
                                                
    264
            setChainWithDefaultRpcUrl("metal", ChainData("Metal", 1750, "https://metall2.drpc.org"));
    265
            setChainWithDefaultRpcUrl("metal_sepolia", ChainData("Metal Sepolia", 1740, "https://testnet.rpc.metall2.com"));
    266
    
                                                    
                                                
    267
            setChainWithDefaultRpcUrl("binary", ChainData("Binary", 624, "https://rpc.zero.thebinaryholdings.com"));
    268
            setChainWithDefaultRpcUrl(
    269
                "binary_sepolia", ChainData("Binary Sepolia", 625, "https://rpc.zero.thebinaryholdings.com")
    270
            );
    271
    
                                                    
                                                
    272
            setChainWithDefaultRpcUrl("orderly", ChainData("Orderly", 291, "https://rpc.orderly.network"));
    273
            setChainWithDefaultRpcUrl(
    274
                "orderly_sepolia", ChainData("Orderly Sepolia", 4460, "https://testnet-rpc.orderly.org")
    275
            );
    276
        }
    277
    
                                                    
                                                
    278
        // set chain info, with priority to chainAlias' rpc url in foundry.toml
    279
        function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {
    280
            string memory rpcUrl = chain.rpcUrl;
    281
            defaultRpcUrls[chainAlias] = rpcUrl;
    282
            chain.rpcUrl = "";
    283
            setChain(chainAlias, chain);
    284
            chain.rpcUrl = rpcUrl; // restore argument
    285
        }
    286
    }
    287
    
                                                    
                                                
    0.0% lib/forge-std/src/StdCheats.sol
    Lines covered: 0 / 7 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    import {StdStorage, stdStorage} from "./StdStorage.sol";
    7
    import {console2} from "./console2.sol";
    8
    import {Vm} from "./Vm.sol";
    9
    
                                                    
                                                
    10
    abstract contract StdCheatsSafe {
    11
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    12
    
                                                    
                                                
    13
        uint256 private constant UINT256_MAX =
    14
            115792089237316195423570985008687907853269984665640564039457584007913129639935;
    15
    
                                                    
                                                
    16
        bool private gasMeteringOff;
    17
    
                                                    
                                                
    18
        // Data structures to parse Transaction objects from the broadcast artifact
    19
        // that conform to EIP1559. The Raw structs is what is parsed from the JSON
    20
        // and then converted to the one that is used by the user for better UX.
    21
    
                                                    
                                                
    22
        struct RawTx1559 {
    23
            string[] arguments;
    24
            address contractAddress;
    25
            string contractName;
    26
            // json value name = function
    27
            string functionSig;
    28
            bytes32 hash;
    29
            // json value name = tx
    30
            RawTx1559Detail txDetail;
    31
            // json value name = type
    32
            string opcode;
    33
        }
    34
    
                                                    
                                                
    35
        struct RawTx1559Detail {
    36
            AccessList[] accessList;
    37
            bytes data;
    38
            address from;
    39
            bytes gas;
    40
            bytes nonce;
    41
            address to;
    42
            bytes txType;
    43
            bytes value;
    44
        }
    45
    
                                                    
                                                
    46
        struct Tx1559 {
    47
            string[] arguments;
    48
            address contractAddress;
    49
            string contractName;
    50
            string functionSig;
    51
            bytes32 hash;
    52
            Tx1559Detail txDetail;
    53
            string opcode;
    54
        }
    55
    
                                                    
                                                
    56
        struct Tx1559Detail {
    57
            AccessList[] accessList;
    58
            bytes data;
    59
            address from;
    60
            uint256 gas;
    61
            uint256 nonce;
    62
            address to;
    63
            uint256 txType;
    64
            uint256 value;
    65
        }
    66
    
                                                    
                                                
    67
        // Data structures to parse Transaction objects from the broadcast artifact
    68
        // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON
    69
        // and then converted to the one that is used by the user for better UX.
    70
    
                                                    
                                                
    71
        struct TxLegacy {
    72
            string[] arguments;
    73
            address contractAddress;
    74
            string contractName;
    75
            string functionSig;
    76
            string hash;
    77
            string opcode;
    78
            TxDetailLegacy transaction;
    79
        }
    80
    
                                                    
                                                
    81
        struct TxDetailLegacy {
    82
            AccessList[] accessList;
    83
            uint256 chainId;
    84
            bytes data;
    85
            address from;
    86
            uint256 gas;
    87
            uint256 gasPrice;
    88
            bytes32 hash;
    89
            uint256 nonce;
    90
            bytes1 opcode;
    91
            bytes32 r;
    92
            bytes32 s;
    93
            uint256 txType;
    94
            address to;
    95
            uint8 v;
    96
            uint256 value;
    97
        }
    98
    
                                                    
                                                
    99
        struct AccessList {
    100
            address accessAddress;
    101
            bytes32[] storageKeys;
    102
        }
    103
    
                                                    
                                                
    104
        // Data structures to parse Receipt objects from the broadcast artifact.
    105
        // The Raw structs is what is parsed from the JSON
    106
        // and then converted to the one that is used by the user for better UX.
    107
    
                                                    
                                                
    108
        struct RawReceipt {
    109
            bytes32 blockHash;
    110
            bytes blockNumber;
    111
            address contractAddress;
    112
            bytes cumulativeGasUsed;
    113
            bytes effectiveGasPrice;
    114
            address from;
    115
            bytes gasUsed;
    116
            RawReceiptLog[] logs;
    117
            bytes logsBloom;
    118
            bytes status;
    119
            address to;
    120
            bytes32 transactionHash;
    121
            bytes transactionIndex;
    122
        }
    123
    
                                                    
                                                
    124
        struct Receipt {
    125
            bytes32 blockHash;
    126
            uint256 blockNumber;
    127
            address contractAddress;
    128
            uint256 cumulativeGasUsed;
    129
            uint256 effectiveGasPrice;
    130
            address from;
    131
            uint256 gasUsed;
    132
            ReceiptLog[] logs;
    133
            bytes logsBloom;
    134
            uint256 status;
    135
            address to;
    136
            bytes32 transactionHash;
    137
            uint256 transactionIndex;
    138
        }
    139
    
                                                    
                                                
    140
        // Data structures to parse the entire broadcast artifact, assuming the
    141
        // transactions conform to EIP1559.
    142
    
                                                    
                                                
    143
        struct EIP1559ScriptArtifact {
    144
            string[] libraries;
    145
            string path;
    146
            string[] pending;
    147
            Receipt[] receipts;
    148
            uint256 timestamp;
    149
            Tx1559[] transactions;
    150
            TxReturn[] txReturns;
    151
        }
    152
    
                                                    
                                                
    153
        struct RawEIP1559ScriptArtifact {
    154
            string[] libraries;
    155
            string path;
    156
            string[] pending;
    157
            RawReceipt[] receipts;
    158
            TxReturn[] txReturns;
    159
            uint256 timestamp;
    160
            RawTx1559[] transactions;
    161
        }
    162
    
                                                    
                                                
    163
        struct RawReceiptLog {
    164
            // json value = address
    165
            address logAddress;
    166
            bytes32 blockHash;
    167
            bytes blockNumber;
    168
            bytes data;
    169
            bytes logIndex;
    170
            bool removed;
    171
            bytes32[] topics;
    172
            bytes32 transactionHash;
    173
            bytes transactionIndex;
    174
            bytes transactionLogIndex;
    175
        }
    176
    
                                                    
                                                
    177
        struct ReceiptLog {
    178
            // json value = address
    179
            address logAddress;
    180
            bytes32 blockHash;
    181
            uint256 blockNumber;
    182
            bytes data;
    183
            uint256 logIndex;
    184
            bytes32[] topics;
    185
            uint256 transactionIndex;
    186
            uint256 transactionLogIndex;
    187
            bool removed;
    188
        }
    189
    
                                                    
                                                
    190
        struct TxReturn {
    191
            string internalType;
    192
            string value;
    193
        }
    194
    
                                                    
                                                
    195
        struct Account {
    196
            address addr;
    197
            uint256 key;
    198
        }
    199
    
                                                    
                                                
    200
        enum AddressType {
    201
            Payable,
    202
            NonPayable,
    203
            ZeroAddress,
    204
            Precompile,
    205
            ForgeAddress
    206
        }
    207
    
                                                    
                                                
    208
        // Checks that `addr` is not blacklisted by token contracts that have a blacklist.
    209
        function assumeNotBlacklisted(address token, address addr) internal view virtual {
    210
            // Nothing to check if `token` is not a contract.
    211
            uint256 tokenCodeSize;
    212
            assembly {
    213
                tokenCodeSize := extcodesize(token)
    214
            }
    215
            require(tokenCodeSize > 0, "StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.");
    216
    
                                                    
                                                
    217
            bool success;
    218
            bytes memory returnData;
    219
    
                                                    
                                                
    220
            // 4-byte selector for `isBlacklisted(address)`, used by USDC.
    221
            (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));
    222
            vm.assume(!success || abi.decode(returnData, (bool)) == false);
    223
    
                                                    
                                                
    224
            // 4-byte selector for `isBlackListed(address)`, used by USDT.
    225
            (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));
    226
            vm.assume(!success || abi.decode(returnData, (bool)) == false);
    227
        }
    228
    
                                                    
                                                
    229
        // Checks that `addr` is not blacklisted by token contracts that have a blacklist.
    230
        // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for
    231
        // backwards compatibility, since this name was used in the original PR which already has
    232
        // a release. This function can be removed in a future release once we want a breaking change.
    233
        function assumeNoBlacklisted(address token, address addr) internal view virtual {
    234
            assumeNotBlacklisted(token, addr);
    235
        }
    236
    
                                                    
                                                
    237
        function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {
    238
            if (addressType == AddressType.Payable) {
    239
                assumeNotPayable(addr);
    240
            } else if (addressType == AddressType.NonPayable) {
    241
                assumePayable(addr);
    242
            } else if (addressType == AddressType.ZeroAddress) {
    243
                assumeNotZeroAddress(addr);
    244
            } else if (addressType == AddressType.Precompile) {
    245
                assumeNotPrecompile(addr);
    246
            } else if (addressType == AddressType.ForgeAddress) {
    247
                assumeNotForgeAddress(addr);
    248
            }
    249
        }
    250
    
                                                    
                                                
    251
        function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {
    252
            assumeAddressIsNot(addr, addressType1);
    253
            assumeAddressIsNot(addr, addressType2);
    254
        }
    255
    
                                                    
                                                
    256
        function assumeAddressIsNot(
    257
            address addr,
    258
            AddressType addressType1,
    259
            AddressType addressType2,
    260
            AddressType addressType3
    261
        ) internal virtual {
    262
            assumeAddressIsNot(addr, addressType1);
    263
            assumeAddressIsNot(addr, addressType2);
    264
            assumeAddressIsNot(addr, addressType3);
    265
        }
    266
    
                                                    
                                                
    267
        function assumeAddressIsNot(
    268
            address addr,
    269
            AddressType addressType1,
    270
            AddressType addressType2,
    271
            AddressType addressType3,
    272
            AddressType addressType4
    273
        ) internal virtual {
    274
            assumeAddressIsNot(addr, addressType1);
    275
            assumeAddressIsNot(addr, addressType2);
    276
            assumeAddressIsNot(addr, addressType3);
    277
            assumeAddressIsNot(addr, addressType4);
    278
        }
    279
    
                                                    
                                                
    280
        // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to
    281
        // `addr` and checking the `success` return value.
    282
        // NOTE: This function may result in state changes depending on the fallback/receive logic
    283
        // implemented by `addr`, which should be taken into account when this function is used.
    284
        function _isPayable(address addr) private returns (bool) {
    285
            require(
    286
                addr.balance < UINT256_MAX,
    287
                "StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds"
    288
            );
    289
            uint256 origBalanceTest = address(this).balance;
    290
            uint256 origBalanceAddr = address(addr).balance;
    291
    
                                                    
                                                
    292
            vm.deal(address(this), 1);
    293
            (bool success,) = payable(addr).call{value: 1}("");
    294
    
                                                    
                                                
    295
            // reset balances
    296
            vm.deal(address(this), origBalanceTest);
    297
            vm.deal(addr, origBalanceAddr);
    298
    
                                                    
                                                
    299
            return success;
    300
        }
    301
    
                                                    
                                                
    302
        // NOTE: This function may result in state changes depending on the fallback/receive logic
    303
        // implemented by `addr`, which should be taken into account when this function is used. See the
    304
        // `_isPayable` method for more information.
    305
        function assumePayable(address addr) internal virtual {
    306
            vm.assume(_isPayable(addr));
    307
        }
    308
    
                                                    
                                                
    309
        function assumeNotPayable(address addr) internal virtual {
    310
            vm.assume(!_isPayable(addr));
    311
        }
    312
    
                                                    
                                                
    313
        function assumeNotZeroAddress(address addr) internal pure virtual {
    314
            vm.assume(addr != address(0));
    315
        }
    316
    
                                                    
                                                
    317
        function assumeNotPrecompile(address addr) internal pure virtual {
    318
            assumeNotPrecompile(addr, _pureChainId());
    319
        }
    320
    
                                                    
                                                
    321
        function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {
    322
            // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific
    323
            // address), but the same rationale for excluding them applies so we include those too.
    324
    
                                                    
                                                
    325
            // These are reserved by Ethereum and may be on all EVM-compatible chains.
    326
            vm.assume(addr < address(0x1) || addr > address(0xff));
    327
    
                                                    
                                                
    328
            // forgefmt: disable-start
    329
            if (chainId == 10 || chainId == 420) {
    330
                // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21
    331
                vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));
    332
            } else if (chainId == 42161 || chainId == 421613) {
    333
                // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains
    334
                vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));
    335
            } else if (chainId == 43114 || chainId == 43113) {
    336
                // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59
    337
                vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));
    338
                vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));
    339
                vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));
    340
            }
    341
            // forgefmt: disable-end
    342
        }
    343
    
                                                    
                                                
    344
        function assumeNotForgeAddress(address addr) internal pure virtual {
    345
            // vm, console, and Create2Deployer addresses
    346
            vm.assume(
    347
                addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67
    348
                    && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C
    349
            );
    350
        }
    351
    
                                                    
                                                
    352
        function assumeUnusedAddress(address addr) internal view virtual {
    353
            uint256 size;
    354
            assembly {
    355
                size := extcodesize(addr)
    356
            }
    357
            vm.assume(size == 0);
    358
    
                                                    
                                                
    359
            assumeNotPrecompile(addr);
    360
            assumeNotZeroAddress(addr);
    361
            assumeNotForgeAddress(addr);
    362
        }
    363
    
                                                    
                                                
    364
        function readEIP1559ScriptArtifact(string memory path)
    365
            internal
    366
            view
    367
            virtual
    368
            returns (EIP1559ScriptArtifact memory)
    369
        {
    370
            string memory data = vm.readFile(path);
    371
            bytes memory parsedData = vm.parseJson(data);
    372
            RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));
    373
            EIP1559ScriptArtifact memory artifact;
    374
            artifact.libraries = rawArtifact.libraries;
    375
            artifact.path = rawArtifact.path;
    376
            artifact.timestamp = rawArtifact.timestamp;
    377
            artifact.pending = rawArtifact.pending;
    378
            artifact.txReturns = rawArtifact.txReturns;
    379
            artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);
    380
            artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);
    381
            return artifact;
    382
        }
    383
    
                                                    
                                                
    384
        function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {
    385
            Tx1559[] memory txs = new Tx1559[](rawTxs.length);
    386
            for (uint256 i; i < rawTxs.length; i++) {
    387
                txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);
    388
            }
    389
            return txs;
    390
        }
    391
    
                                                    
                                                
    392
        function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {
    393
            Tx1559 memory transaction;
    394
            transaction.arguments = rawTx.arguments;
    395
            transaction.contractName = rawTx.contractName;
    396
            transaction.functionSig = rawTx.functionSig;
    397
            transaction.hash = rawTx.hash;
    398
            transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);
    399
            transaction.opcode = rawTx.opcode;
    400
            return transaction;
    401
        }
    402
    
                                                    
                                                
    403
        function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)
    404
            internal
    405
            pure
    406
            virtual
    407
            returns (Tx1559Detail memory)
    408
        {
    409
            Tx1559Detail memory txDetail;
    410
            txDetail.data = rawDetail.data;
    411
            txDetail.from = rawDetail.from;
    412
            txDetail.to = rawDetail.to;
    413
            txDetail.nonce = _bytesToUint(rawDetail.nonce);
    414
            txDetail.txType = _bytesToUint(rawDetail.txType);
    415
            txDetail.value = _bytesToUint(rawDetail.value);
    416
            txDetail.gas = _bytesToUint(rawDetail.gas);
    417
            txDetail.accessList = rawDetail.accessList;
    418
            return txDetail;
    419
        }
    420
    
                                                    
                                                
    421
        function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {
    422
            string memory deployData = vm.readFile(path);
    423
            bytes memory parsedDeployData = vm.parseJson(deployData, ".transactions");
    424
            RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));
    425
            return rawToConvertedEIPTx1559s(rawTxs);
    426
        }
    427
    
                                                    
                                                
    428
        function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {
    429
            string memory deployData = vm.readFile(path);
    430
            string memory key = string(abi.encodePacked(".transactions[", vm.toString(index), "]"));
    431
            bytes memory parsedDeployData = vm.parseJson(deployData, key);
    432
            RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));
    433
            return rawToConvertedEIPTx1559(rawTx);
    434
        }
    435
    
                                                    
                                                
    436
        // Analogous to readTransactions, but for receipts.
    437
        function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {
    438
            string memory deployData = vm.readFile(path);
    439
            bytes memory parsedDeployData = vm.parseJson(deployData, ".receipts");
    440
            RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));
    441
            return rawToConvertedReceipts(rawReceipts);
    442
        }
    443
    
                                                    
                                                
    444
        function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {
    445
            string memory deployData = vm.readFile(path);
    446
            string memory key = string(abi.encodePacked(".receipts[", vm.toString(index), "]"));
    447
            bytes memory parsedDeployData = vm.parseJson(deployData, key);
    448
            RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));
    449
            return rawToConvertedReceipt(rawReceipt);
    450
        }
    451
    
                                                    
                                                
    452
        function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {
    453
            Receipt[] memory receipts = new Receipt[](rawReceipts.length);
    454
            for (uint256 i; i < rawReceipts.length; i++) {
    455
                receipts[i] = rawToConvertedReceipt(rawReceipts[i]);
    456
            }
    457
            return receipts;
    458
        }
    459
    
                                                    
                                                
    460
        function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {
    461
            Receipt memory receipt;
    462
            receipt.blockHash = rawReceipt.blockHash;
    463
            receipt.to = rawReceipt.to;
    464
            receipt.from = rawReceipt.from;
    465
            receipt.contractAddress = rawReceipt.contractAddress;
    466
            receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);
    467
            receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);
    468
            receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);
    469
            receipt.status = _bytesToUint(rawReceipt.status);
    470
            receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);
    471
            receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);
    472
            receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);
    473
            receipt.logsBloom = rawReceipt.logsBloom;
    474
            receipt.transactionHash = rawReceipt.transactionHash;
    475
            return receipt;
    476
        }
    477
    
                                                    
                                                
    478
        function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)
    479
            internal
    480
            pure
    481
            virtual
    482
            returns (ReceiptLog[] memory)
    483
        {
    484
            ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);
    485
            for (uint256 i; i < rawLogs.length; i++) {
    486
                logs[i].logAddress = rawLogs[i].logAddress;
    487
                logs[i].blockHash = rawLogs[i].blockHash;
    488
                logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);
    489
                logs[i].data = rawLogs[i].data;
    490
                logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);
    491
                logs[i].topics = rawLogs[i].topics;
    492
                logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);
    493
                logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);
    494
                logs[i].removed = rawLogs[i].removed;
    495
            }
    496
            return logs;
    497
        }
    498
    
                                                    
                                                
    499
        // Deploy a contract by fetching the contract bytecode from
    500
        // the artifacts directory
    501
        // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`
    502
        function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {
    503
            bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
    504
            /// @solidity memory-safe-assembly
    505
            assembly {
    506
                addr := create(0, add(bytecode, 0x20), mload(bytecode))
    507
            }
    508
    
                                                    
                                                
    509
            require(addr != address(0), "StdCheats deployCode(string,bytes): Deployment failed.");
    510
        }
    511
    
                                                    
                                                
    512
        function deployCode(string memory what) internal virtual returns (address addr) {
    513
            bytes memory bytecode = vm.getCode(what);
    514
            /// @solidity memory-safe-assembly
    515
            assembly {
    516
                addr := create(0, add(bytecode, 0x20), mload(bytecode))
    517
            }
    518
    
                                                    
                                                
    519
            require(addr != address(0), "StdCheats deployCode(string): Deployment failed.");
    520
        }
    521
    
                                                    
                                                
    522
        /// @dev deploy contract with value on construction
    523
        function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {
    524
            bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
    525
            /// @solidity memory-safe-assembly
    526
            assembly {
    527
                addr := create(val, add(bytecode, 0x20), mload(bytecode))
    528
            }
    529
    
                                                    
                                                
    530
            require(addr != address(0), "StdCheats deployCode(string,bytes,uint256): Deployment failed.");
    531
        }
    532
    
                                                    
                                                
    533
        function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {
    534
            bytes memory bytecode = vm.getCode(what);
    535
            /// @solidity memory-safe-assembly
    536
            assembly {
    537
                addr := create(val, add(bytecode, 0x20), mload(bytecode))
    538
            }
    539
    
                                                    
                                                
    540
            require(addr != address(0), "StdCheats deployCode(string,uint256): Deployment failed.");
    541
        }
    542
    
                                                    
                                                
    543
        // creates a labeled address and the corresponding private key
    544
        function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {
    545
            privateKey = uint256(keccak256(abi.encodePacked(name)));
    546
            addr = vm.addr(privateKey);
    547
            vm.label(addr, name);
    548
        }
    549
    
                                                    
                                                
    550
        // creates a labeled address
    551
        function makeAddr(string memory name) internal virtual returns (address addr) {
    552
            (addr,) = makeAddrAndKey(name);
    553
        }
    554
    
                                                    
                                                
    555
        // Destroys an account immediately, sending the balance to beneficiary.
    556
        // Destroying means: balance will be zero, code will be empty, and nonce will be 0
    557
        // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce
    558
        // only after tx ends, this will run immediately.
    559
        function destroyAccount(address who, address beneficiary) internal virtual {
    560
            uint256 currBalance = who.balance;
    561
            vm.etch(who, abi.encode());
    562
            vm.deal(who, 0);
    563
            vm.resetNonce(who);
    564
    
                                                    
                                                
    565
            uint256 beneficiaryBalance = beneficiary.balance;
    566
            vm.deal(beneficiary, currBalance + beneficiaryBalance);
    567
        }
    568
    
                                                    
                                                
    569
        // creates a struct containing both a labeled address and the corresponding private key
    570
        function makeAccount(string memory name) internal virtual returns (Account memory account) {
    571
            (account.addr, account.key) = makeAddrAndKey(name);
    572
        }
    573
    
                                                    
                                                
    574
        function deriveRememberKey(string memory mnemonic, uint32 index)
    575
            internal
    576
            virtual
    577
            returns (address who, uint256 privateKey)
    578
        {
    579
            privateKey = vm.deriveKey(mnemonic, index);
    580
            who = vm.rememberKey(privateKey);
    581
        }
    582
    
                                                    
                                                
    583
        function _bytesToUint(bytes memory b) private pure returns (uint256) {
    584
            require(b.length <= 32, "StdCheats _bytesToUint(bytes): Bytes length exceeds 32.");
    585
            return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
    586
        }
    587
    
                                                    
                                                
    588
        function isFork() internal view virtual returns (bool status) {
    589
            try vm.activeFork() {
    590
                status = true;
    591
            } catch (bytes memory) {}
    592
        }
    593
    
                                                    
                                                
    594
        modifier skipWhenForking() {
    595
            if (!isFork()) {
    596
                _;
    597
            }
    598
        }
    599
    
                                                    
                                                
    600
        modifier skipWhenNotForking() {
    601
            if (isFork()) {
    602
                _;
    603
            }
    604
        }
    605
    
                                                    
                                                
    606
        modifier noGasMetering() {
    607
            vm.pauseGasMetering();
    608
            // To prevent turning gas monitoring back on with nested functions that use this modifier,
    609
            // we check if gasMetering started in the off position. If it did, we don't want to turn
    610
            // it back on until we exit the top level function that used the modifier
    611
            //
    612
            // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.
    613
            // funcA will have `gasStartedOff` as false, funcB will have it as true,
    614
            // so we only turn metering back on at the end of the funcA
    615
            bool gasStartedOff = gasMeteringOff;
    616
            gasMeteringOff = true;
    617
    
                                                    
                                                
    618
            _;
    619
    
                                                    
                                                
    620
            // if gas metering was on when this modifier was called, turn it back on at the end
    621
            if (!gasStartedOff) {
    622
                gasMeteringOff = false;
    623
                vm.resumeGasMetering();
    624
            }
    625
        }
    626
    
                                                    
                                                
    627
        // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no
    628
        // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We
    629
        // can't simply access the chain ID in a normal view or pure function because the solc View Pure
    630
        // Checker changed `chainid` from pure to view in 0.8.0.
    631
        function _viewChainId() private view returns (uint256 chainId) {
    632
            // Assembly required since `block.chainid` was introduced in 0.8.0.
    633
            assembly {
    634
                chainId := chainid()
    635
            }
    636
    
                                                    
                                                
    637
            address(this); // Silence warnings in older Solc versions.
    638
        }
    639
    
                                                    
                                                
    640
        function _pureChainId() private pure returns (uint256 chainId) {
    641
            function() internal view returns (uint256) fnIn = _viewChainId;
    642
            function() internal pure returns (uint256) pureChainId;
    643
            assembly {
    644
                pureChainId := fnIn
    645
            }
    646
            chainId = pureChainId();
    647
        }
    648
    }
    649
    
                                                    
                                                
    650
    // Wrappers around cheatcodes to avoid footguns
    651
    abstract contract StdCheats is StdCheatsSafe {
    652
        using stdStorage for StdStorage;
    653
    
                                                    
                                                
    654
        StdStorage private stdstore;
    655
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    656
        address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
    657
    
                                                    
                                                
    658
        // Skip forward or rewind time by the specified number of seconds
    659
        function skip(uint256 time) internal virtual {
    660
            vm.warp(vm.getBlockTimestamp() + time);
    661
        }
    662
    
                                                    
                                                
    663
        function rewind(uint256 time) internal virtual {
    664
            vm.warp(vm.getBlockTimestamp() - time);
    665
        }
    666
    
                                                    
                                                
    667
        // Setup a prank from an address that has some ether
    668
        function hoax(address msgSender) internal virtual {
    669
            vm.deal(msgSender, 1 << 128);
    670
            vm.prank(msgSender);
    671
        }
    672
    
                                                    
                                                
    673
        function hoax(address msgSender, uint256 give) internal virtual {
    674
            vm.deal(msgSender, give);
    675
            vm.prank(msgSender);
    676
        }
    677
    
                                                    
                                                
    678
        function hoax(address msgSender, address origin) internal virtual {
    679
            vm.deal(msgSender, 1 << 128);
    680
            vm.prank(msgSender, origin);
    681
        }
    682
    
                                                    
                                                
    683
        function hoax(address msgSender, address origin, uint256 give) internal virtual {
    684
            vm.deal(msgSender, give);
    685
            vm.prank(msgSender, origin);
    686
        }
    687
    
                                                    
                                                
    688
        // Start perpetual prank from an address that has some ether
    689
        function startHoax(address msgSender) internal virtual {
    690
            vm.deal(msgSender, 1 << 128);
    691
            vm.startPrank(msgSender);
    692
        }
    693
    
                                                    
                                                
    694
        function startHoax(address msgSender, uint256 give) internal virtual {
    695
            vm.deal(msgSender, give);
    696
            vm.startPrank(msgSender);
    697
        }
    698
    
                                                    
                                                
    699
        // Start perpetual prank from an address that has some ether
    700
        // tx.origin is set to the origin parameter
    701
        function startHoax(address msgSender, address origin) internal virtual {
    702
            vm.deal(msgSender, 1 << 128);
    703
            vm.startPrank(msgSender, origin);
    704
        }
    705
    
                                                    
                                                
    706
        function startHoax(address msgSender, address origin, uint256 give) internal virtual {
    707
            vm.deal(msgSender, give);
    708
            vm.startPrank(msgSender, origin);
    709
        }
    710
    
                                                    
                                                
    711
        function changePrank(address msgSender) internal virtual {
    712
            console2_log_StdCheats("changePrank is deprecated. Please use vm.startPrank instead.");
    713
            vm.stopPrank();
    714
            vm.startPrank(msgSender);
    715
        }
    716
    
                                                    
                                                
    717
        function changePrank(address msgSender, address txOrigin) internal virtual {
    718
            vm.stopPrank();
    719
            vm.startPrank(msgSender, txOrigin);
    720
        }
    721
    
                                                    
                                                
    722
        // The same as Vm's `deal`
    723
        // Use the alternative signature for ERC20 tokens
    724
        function deal(address to, uint256 give) internal virtual {
    725
            vm.deal(to, give);
    726
        }
    727
    
                                                    
                                                
    728
        // Set the balance of an account for any ERC20 token
    729
        // Use the alternative signature to update `totalSupply`
    730
        function deal(address token, address to, uint256 give) internal virtual {
    731
            deal(token, to, give, false);
    732
        }
    733
    
                                                    
                                                
    734
        // Set the balance of an account for any ERC1155 token
    735
        // Use the alternative signature to update `totalSupply`
    736
        function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {
    737
            dealERC1155(token, to, id, give, false);
    738
        }
    739
    
                                                    
                                                
    740
        function deal(address token, address to, uint256 give, bool adjust) internal virtual {
    741
            // get current balance
    742
            (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
    743
            uint256 prevBal = abi.decode(balData, (uint256));
    744
    
                                                    
                                                
    745
            // update balance
    746
            stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);
    747
    
                                                    
                                                
    748
            // update total supply
    749
            if (adjust) {
    750
                (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));
    751
                uint256 totSup = abi.decode(totSupData, (uint256));
    752
                if (give < prevBal) {
    753
                    totSup -= (prevBal - give);
    754
                } else {
    755
                    totSup += (give - prevBal);
    756
                }
    757
                stdstore.target(token).sig(0x18160ddd).checked_write(totSup);
    758
            }
    759
        }
    760
    
                                                    
                                                
    761
        function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {
    762
            // get current balance
    763
            (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));
    764
            uint256 prevBal = abi.decode(balData, (uint256));
    765
    
                                                    
                                                
    766
            // update balance
    767
            stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);
    768
    
                                                    
                                                
    769
            // update total supply
    770
            if (adjust) {
    771
                (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));
    772
                require(
    773
                    totSupData.length != 0,
    774
                    "StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply."
    775
                );
    776
                uint256 totSup = abi.decode(totSupData, (uint256));
    777
                if (give < prevBal) {
    778
                    totSup -= (prevBal - give);
    779
                } else {
    780
                    totSup += (give - prevBal);
    781
                }
    782
                stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);
    783
            }
    784
        }
    785
    
                                                    
                                                
    786
        function dealERC721(address token, address to, uint256 id) internal virtual {
    787
            // check if token id is already minted and the actual owner.
    788
            (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));
    789
            require(successMinted, "StdCheats deal(address,address,uint,bool): id not minted.");
    790
    
                                                    
                                                
    791
            // get owner current balance
    792
            (, bytes memory fromBalData) =
    793
                token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));
    794
            uint256 fromPrevBal = abi.decode(fromBalData, (uint256));
    795
    
                                                    
                                                
    796
            // get new user current balance
    797
            (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
    798
            uint256 toPrevBal = abi.decode(toBalData, (uint256));
    799
    
                                                    
                                                
    800
            // update balances
    801
            stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);
    802
            stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);
    803
    
                                                    
                                                
    804
            // update owner
    805
            stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);
    806
        }
    807
    
                                                    
                                                
    808
        function deployCodeTo(string memory what, address where) internal virtual {
    809
            deployCodeTo(what, "", 0, where);
    810
        }
    811
    
                                                    
                                                
    812
        function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {
    813
            deployCodeTo(what, args, 0, where);
    814
        }
    815
    
                                                    
                                                
    816
        function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {
    817
            bytes memory creationCode = vm.getCode(what);
    818
            vm.etch(where, abi.encodePacked(creationCode, args));
    819
            (bool success, bytes memory runtimeBytecode) = where.call{value: value}("");
    820
            require(success, "StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.");
    821
            vm.etch(where, runtimeBytecode);
    822
        }
    823
    
                                                    
                                                
    824
        // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.
    825
        function console2_log_StdCheats(string memory p0) private view {
    826
            (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature("log(string)", p0));
    827
            status;
    828
        }
    829
    }
    830
    
                                                    
                                                
    100.0% lib/forge-std/src/StdConstants.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    import {IMulticall3} from "./interfaces/IMulticall3.sol";
    5
    import {Vm} from "./Vm.sol";
    6
    
                                                    
                                                
    7
    ✓ 13
    library StdConstants {
    8
        /// @dev Cheat code address.
    9
        /// Calculated as `address(uint160(uint256(keccak256("hevm cheat code"))))`.
    10
        Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
    11
        /// @dev console.sol and console2.sol work by executing a staticcall to this address.
    12
        /// Calculated as `address(uint160(uint88(bytes11("console.log"))))`.
    13
        address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;
    14
        /// @dev Used when deploying with create2.
    15
        /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.
    16
        address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
    17
        /// @dev The default address for tx.origin and msg.sender.
    18
        /// Calculated as `address(uint160(uint256(keccak256("foundry default caller"))))`.
    19
        address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;
    20
        /// @dev The address of the first contract `CREATE`d by a running test contract.
    21
        /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.
    22
        /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.
    23
        address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;
    24
        /// @dev Deterministic deployment address of the Multicall3 contract.
    25
        /// Taken from https://www.multicall3.com.
    26
        IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);
    27
        /// @dev The order of the secp256k1 curve.
    28
        uint256 internal constant SECP256K1_ORDER =
    29
            115792089237316195423570985008687907852837564279074904382605163141518161494337;
    30
    }
    31
    
                                                    
                                                
    100.0% lib/forge-std/src/StdError.sol
    Lines covered: 10 / 10 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // Panics work for versions >=0.8.0, but we lowered the pragma to make this compatible with Test
    3
    pragma solidity >=0.6.2 <0.9.0;
    4
    
                                                    
                                                
    5
    ✓ 1
    library stdError {
    6
    ✓ 2
        bytes public constant assertionError = abi.encodeWithSignature("Panic(uint256)", 0x01);
    7
    ✓ 2
        bytes public constant arithmeticError = abi.encodeWithSignature("Panic(uint256)", 0x11);
    8
    ✓ 4
        bytes public constant divisionError = abi.encodeWithSignature("Panic(uint256)", 0x12);
    9
    ✓ 2
        bytes public constant enumConversionError = abi.encodeWithSignature("Panic(uint256)", 0x21);
    10
    ✓ 2
        bytes public constant encodeStorageError = abi.encodeWithSignature("Panic(uint256)", 0x22);
    11
    ✓ 2
        bytes public constant popError = abi.encodeWithSignature("Panic(uint256)", 0x31);
    12
    ✓ 2
        bytes public constant indexOOBError = abi.encodeWithSignature("Panic(uint256)", 0x32);
    13
    ✓ 2
        bytes public constant memOverflowError = abi.encodeWithSignature("Panic(uint256)", 0x41);
    14
    ✓ 2
        bytes public constant zeroVarError = abi.encodeWithSignature("Panic(uint256)", 0x51);
    15
    }
    16
    
                                                    
                                                
    0.0% lib/forge-std/src/StdInvariant.sol
    Lines covered: 0 / 10 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    abstract contract StdInvariant {
    7
        struct FuzzSelector {
    8
            address addr;
    9
            bytes4[] selectors;
    10
        }
    11
    
                                                    
                                                
    12
        struct FuzzArtifactSelector {
    13
            string artifact;
    14
            bytes4[] selectors;
    15
        }
    16
    
                                                    
                                                
    17
        struct FuzzInterface {
    18
            address addr;
    19
            string[] artifacts;
    20
        }
    21
    
                                                    
                                                
    22
        address[] private _excludedContracts;
    23
        address[] private _excludedSenders;
    24
        address[] private _targetedContracts;
    25
        address[] private _targetedSenders;
    26
    
                                                    
                                                
    27
        string[] private _excludedArtifacts;
    28
        string[] private _targetedArtifacts;
    29
    
                                                    
                                                
    30
        FuzzArtifactSelector[] private _targetedArtifactSelectors;
    31
    
                                                    
                                                
    32
        FuzzSelector[] private _excludedSelectors;
    33
        FuzzSelector[] private _targetedSelectors;
    34
    
                                                    
                                                
    35
        FuzzInterface[] private _targetedInterfaces;
    36
    
                                                    
                                                
    37
        // Functions for users:
    38
        // These are intended to be called in tests.
    39
    
                                                    
                                                
    40
        function excludeContract(address newExcludedContract_) internal {
    41
            _excludedContracts.push(newExcludedContract_);
    42
        }
    43
    
                                                    
                                                
    44
        function excludeSelector(FuzzSelector memory newExcludedSelector_) internal {
    45
            _excludedSelectors.push(newExcludedSelector_);
    46
        }
    47
    
                                                    
                                                
    48
        function excludeSender(address newExcludedSender_) internal {
    49
            _excludedSenders.push(newExcludedSender_);
    50
        }
    51
    
                                                    
                                                
    52
        function excludeArtifact(string memory newExcludedArtifact_) internal {
    53
            _excludedArtifacts.push(newExcludedArtifact_);
    54
        }
    55
    
                                                    
                                                
    56
        function targetArtifact(string memory newTargetedArtifact_) internal {
    57
            _targetedArtifacts.push(newTargetedArtifact_);
    58
        }
    59
    
                                                    
                                                
    60
        function targetArtifactSelector(FuzzArtifactSelector memory newTargetedArtifactSelector_) internal {
    61
            _targetedArtifactSelectors.push(newTargetedArtifactSelector_);
    62
        }
    63
    
                                                    
                                                
    64
        function targetContract(address newTargetedContract_) internal {
    65
            _targetedContracts.push(newTargetedContract_);
    66
        }
    67
    
                                                    
                                                
    68
        function targetSelector(FuzzSelector memory newTargetedSelector_) internal {
    69
            _targetedSelectors.push(newTargetedSelector_);
    70
        }
    71
    
                                                    
                                                
    72
        function targetSender(address newTargetedSender_) internal {
    73
            _targetedSenders.push(newTargetedSender_);
    74
        }
    75
    
                                                    
                                                
    76
        function targetInterface(FuzzInterface memory newTargetedInterface_) internal {
    77
            _targetedInterfaces.push(newTargetedInterface_);
    78
        }
    79
    
                                                    
                                                
    80
        // Functions for forge:
    81
        // These are called by forge to run invariant tests and don't need to be called in tests.
    82
    
                                                    
                                                
    83
        function excludeArtifacts() public view returns (string[] memory excludedArtifacts_) {
    84
            excludedArtifacts_ = _excludedArtifacts;
    85
        }
    86
    
                                                    
                                                
    87
        function excludeContracts() public view returns (address[] memory excludedContracts_) {
    88
            excludedContracts_ = _excludedContracts;
    89
        }
    90
    
                                                    
                                                
    91
        function excludeSelectors() public view returns (FuzzSelector[] memory excludedSelectors_) {
    92
            excludedSelectors_ = _excludedSelectors;
    93
        }
    94
    
                                                    
                                                
    95
        function excludeSenders() public view returns (address[] memory excludedSenders_) {
    96
            excludedSenders_ = _excludedSenders;
    97
        }
    98
    
                                                    
                                                
    99
        function targetArtifacts() public view returns (string[] memory targetedArtifacts_) {
    100
            targetedArtifacts_ = _targetedArtifacts;
    101
        }
    102
    
                                                    
                                                
    103
        function targetArtifactSelectors() public view returns (FuzzArtifactSelector[] memory targetedArtifactSelectors_) {
    104
            targetedArtifactSelectors_ = _targetedArtifactSelectors;
    105
        }
    106
    
                                                    
                                                
    107
        function targetContracts() public view returns (address[] memory targetedContracts_) {
    108
            targetedContracts_ = _targetedContracts;
    109
        }
    110
    
                                                    
                                                
    111
        function targetSelectors() public view returns (FuzzSelector[] memory targetedSelectors_) {
    112
            targetedSelectors_ = _targetedSelectors;
    113
        }
    114
    
                                                    
                                                
    115
        function targetSenders() public view returns (address[] memory targetedSenders_) {
    116
            targetedSenders_ = _targetedSenders;
    117
        }
    118
    
                                                    
                                                
    119
        function targetInterfaces() public view returns (FuzzInterface[] memory targetedInterfaces_) {
    120
            targetedInterfaces_ = _targetedInterfaces;
    121
        }
    122
    }
    123
    
                                                    
                                                
    100.0% lib/forge-std/src/StdJson.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.0 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    import {VmSafe} from "./Vm.sol";
    7
    
                                                    
                                                
    8
    // Helpers for parsing and writing JSON files
    9
    // To parse:
    10
    // ```
    11
    // using stdJson for string;
    12
    // string memory json = vm.readFile("<some_path>");
    13
    // json.readUint("<json_path>");
    14
    // ```
    15
    // To write:
    16
    // ```
    17
    // using stdJson for string;
    18
    // string memory json = "json";
    19
    // json.serialize("a", uint256(123));
    20
    // string memory semiFinal = json.serialize("b", string("test"));
    21
    // string memory finalJson = json.serialize("c", semiFinal);
    22
    // finalJson.write("<some_path>");
    23
    // ```
    24
    
                                                    
                                                
    25
    ✓ 13
    library stdJson {
    26
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    27
    
                                                    
                                                
    28
        function keyExists(string memory json, string memory key) internal view returns (bool) {
    29
            return vm.keyExistsJson(json, key);
    30
        }
    31
    
                                                    
                                                
    32
        function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {
    33
            return vm.parseJson(json, key);
    34
        }
    35
    
                                                    
                                                
    36
        function readUint(string memory json, string memory key) internal pure returns (uint256) {
    37
            return vm.parseJsonUint(json, key);
    38
        }
    39
    
                                                    
                                                
    40
        function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {
    41
            return vm.parseJsonUintArray(json, key);
    42
        }
    43
    
                                                    
                                                
    44
        function readInt(string memory json, string memory key) internal pure returns (int256) {
    45
            return vm.parseJsonInt(json, key);
    46
        }
    47
    
                                                    
                                                
    48
        function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {
    49
            return vm.parseJsonIntArray(json, key);
    50
        }
    51
    
                                                    
                                                
    52
        function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {
    53
            return vm.parseJsonBytes32(json, key);
    54
        }
    55
    
                                                    
                                                
    56
        function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {
    57
            return vm.parseJsonBytes32Array(json, key);
    58
        }
    59
    
                                                    
                                                
    60
        function readString(string memory json, string memory key) internal pure returns (string memory) {
    61
            return vm.parseJsonString(json, key);
    62
        }
    63
    
                                                    
                                                
    64
        function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {
    65
            return vm.parseJsonStringArray(json, key);
    66
        }
    67
    
                                                    
                                                
    68
        function readAddress(string memory json, string memory key) internal pure returns (address) {
    69
            return vm.parseJsonAddress(json, key);
    70
        }
    71
    
                                                    
                                                
    72
        function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {
    73
            return vm.parseJsonAddressArray(json, key);
    74
        }
    75
    
                                                    
                                                
    76
        function readBool(string memory json, string memory key) internal pure returns (bool) {
    77
            return vm.parseJsonBool(json, key);
    78
        }
    79
    
                                                    
                                                
    80
        function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {
    81
            return vm.parseJsonBoolArray(json, key);
    82
        }
    83
    
                                                    
                                                
    84
        function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {
    85
            return vm.parseJsonBytes(json, key);
    86
        }
    87
    
                                                    
                                                
    88
        function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {
    89
            return vm.parseJsonBytesArray(json, key);
    90
        }
    91
    
                                                    
                                                
    92
        function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {
    93
            return keyExists(json, key) ? readUint(json, key) : defaultValue;
    94
        }
    95
    
                                                    
                                                
    96
        function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)
    97
            internal
    98
            view
    99
            returns (uint256[] memory)
    100
        {
    101
            return keyExists(json, key) ? readUintArray(json, key) : defaultValue;
    102
        }
    103
    
                                                    
                                                
    104
        function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {
    105
            return keyExists(json, key) ? readInt(json, key) : defaultValue;
    106
        }
    107
    
                                                    
                                                
    108
        function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)
    109
            internal
    110
            view
    111
            returns (int256[] memory)
    112
        {
    113
            return keyExists(json, key) ? readIntArray(json, key) : defaultValue;
    114
        }
    115
    
                                                    
                                                
    116
        function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)
    117
            internal
    118
            view
    119
            returns (bytes32)
    120
        {
    121
            return keyExists(json, key) ? readBytes32(json, key) : defaultValue;
    122
        }
    123
    
                                                    
                                                
    124
        function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)
    125
            internal
    126
            view
    127
            returns (bytes32[] memory)
    128
        {
    129
            return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;
    130
        }
    131
    
                                                    
                                                
    132
        function readStringOr(string memory json, string memory key, string memory defaultValue)
    133
            internal
    134
            view
    135
            returns (string memory)
    136
        {
    137
            return keyExists(json, key) ? readString(json, key) : defaultValue;
    138
        }
    139
    
                                                    
                                                
    140
        function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)
    141
            internal
    142
            view
    143
            returns (string[] memory)
    144
        {
    145
            return keyExists(json, key) ? readStringArray(json, key) : defaultValue;
    146
        }
    147
    
                                                    
                                                
    148
        function readAddressOr(string memory json, string memory key, address defaultValue)
    149
            internal
    150
            view
    151
            returns (address)
    152
        {
    153
            return keyExists(json, key) ? readAddress(json, key) : defaultValue;
    154
        }
    155
    
                                                    
                                                
    156
        function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)
    157
            internal
    158
            view
    159
            returns (address[] memory)
    160
        {
    161
            return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;
    162
        }
    163
    
                                                    
                                                
    164
        function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {
    165
            return keyExists(json, key) ? readBool(json, key) : defaultValue;
    166
        }
    167
    
                                                    
                                                
    168
        function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)
    169
            internal
    170
            view
    171
            returns (bool[] memory)
    172
        {
    173
            return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;
    174
        }
    175
    
                                                    
                                                
    176
        function readBytesOr(string memory json, string memory key, bytes memory defaultValue)
    177
            internal
    178
            view
    179
            returns (bytes memory)
    180
        {
    181
            return keyExists(json, key) ? readBytes(json, key) : defaultValue;
    182
        }
    183
    
                                                    
                                                
    184
        function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)
    185
            internal
    186
            view
    187
            returns (bytes[] memory)
    188
        {
    189
            return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;
    190
        }
    191
    
                                                    
                                                
    192
        function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
    193
            return vm.serializeJson(jsonKey, rootObject);
    194
        }
    195
    
                                                    
                                                
    196
        function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
    197
            return vm.serializeBool(jsonKey, key, value);
    198
        }
    199
    
                                                    
                                                
    200
        function serialize(string memory jsonKey, string memory key, bool[] memory value)
    201
            internal
    202
            returns (string memory)
    203
        {
    204
            return vm.serializeBool(jsonKey, key, value);
    205
        }
    206
    
                                                    
                                                
    207
        function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
    208
            return vm.serializeUint(jsonKey, key, value);
    209
        }
    210
    
                                                    
                                                
    211
        function serialize(string memory jsonKey, string memory key, uint256[] memory value)
    212
            internal
    213
            returns (string memory)
    214
        {
    215
            return vm.serializeUint(jsonKey, key, value);
    216
        }
    217
    
                                                    
                                                
    218
        function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
    219
            return vm.serializeInt(jsonKey, key, value);
    220
        }
    221
    
                                                    
                                                
    222
        function serialize(string memory jsonKey, string memory key, int256[] memory value)
    223
            internal
    224
            returns (string memory)
    225
        {
    226
            return vm.serializeInt(jsonKey, key, value);
    227
        }
    228
    
                                                    
                                                
    229
        function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
    230
            return vm.serializeAddress(jsonKey, key, value);
    231
        }
    232
    
                                                    
                                                
    233
        function serialize(string memory jsonKey, string memory key, address[] memory value)
    234
            internal
    235
            returns (string memory)
    236
        {
    237
            return vm.serializeAddress(jsonKey, key, value);
    238
        }
    239
    
                                                    
                                                
    240
        function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
    241
            return vm.serializeBytes32(jsonKey, key, value);
    242
        }
    243
    
                                                    
                                                
    244
        function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
    245
            internal
    246
            returns (string memory)
    247
        {
    248
            return vm.serializeBytes32(jsonKey, key, value);
    249
        }
    250
    
                                                    
                                                
    251
        function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
    252
            return vm.serializeBytes(jsonKey, key, value);
    253
        }
    254
    
                                                    
                                                
    255
        function serialize(string memory jsonKey, string memory key, bytes[] memory value)
    256
            internal
    257
            returns (string memory)
    258
        {
    259
            return vm.serializeBytes(jsonKey, key, value);
    260
        }
    261
    
                                                    
                                                
    262
        function serialize(string memory jsonKey, string memory key, string memory value)
    263
            internal
    264
            returns (string memory)
    265
        {
    266
            return vm.serializeString(jsonKey, key, value);
    267
        }
    268
    
                                                    
                                                
    269
        function serialize(string memory jsonKey, string memory key, string[] memory value)
    270
            internal
    271
            returns (string memory)
    272
        {
    273
            return vm.serializeString(jsonKey, key, value);
    274
        }
    275
    
                                                    
                                                
    276
        function write(string memory jsonKey, string memory path) internal {
    277
            vm.writeJson(jsonKey, path);
    278
        }
    279
    
                                                    
                                                
    280
        function write(string memory jsonKey, string memory path, string memory valueKey) internal {
    281
            vm.writeJson(jsonKey, path, valueKey);
    282
        }
    283
    }
    284
    
                                                    
                                                
    100.0% lib/forge-std/src/StdMath.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    ✓ 13
    library stdMath {
    5
        int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;
    6
    
                                                    
                                                
    7
        function abs(int256 a) internal pure returns (uint256) {
    8
            // Required or it will fail when `a = type(int256).min`
    9
            if (a == INT256_MIN) {
    10
                return 57896044618658097711785492504343953926634992332820282019728792003956564819968;
    11
            }
    12
    
                                                    
                                                
    13
            return uint256(a > 0 ? a : -a);
    14
        }
    15
    
                                                    
                                                
    16
        function delta(uint256 a, uint256 b) internal pure returns (uint256) {
    17
            return a > b ? a - b : b - a;
    18
        }
    19
    
                                                    
                                                
    20
        function delta(int256 a, int256 b) internal pure returns (uint256) {
    21
            // a and b are of the same sign
    22
            // this works thanks to two's complement, the left-most bit is the sign bit
    23
            if ((a ^ b) > -1) {
    24
                return delta(abs(a), abs(b));
    25
            }
    26
    
                                                    
                                                
    27
            // a and b are of opposite signs
    28
            return abs(a) + abs(b);
    29
        }
    30
    
                                                    
                                                
    31
        function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {
    32
            uint256 absDelta = delta(a, b);
    33
    
                                                    
                                                
    34
            return absDelta * 1e18 / b;
    35
        }
    36
    
                                                    
                                                
    37
        function percentDelta(int256 a, int256 b) internal pure returns (uint256) {
    38
            uint256 absDelta = delta(a, b);
    39
            uint256 absB = abs(b);
    40
    
                                                    
                                                
    41
            return absDelta * 1e18 / absB;
    42
        }
    43
    }
    44
    
                                                    
                                                
    2.2% lib/forge-std/src/StdStorage.sol
    Lines covered: 2 / 89 (2.2%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    import {Vm} from "./Vm.sol";
    5
    
                                                    
                                                
    6
    struct FindData {
    7
        uint256 slot;
    8
        uint256 offsetLeft;
    9
        uint256 offsetRight;
    10
        bool found;
    11
    }
    12
    
                                                    
                                                
    13
    struct StdStorage {
    14
        mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;
    15
        bytes32[] _keys;
    16
        bytes4 _sig;
    17
        uint256 _depth;
    18
        address _target;
    19
        bytes32 _set;
    20
        bool _enable_packed_slots;
    21
        bytes _calldata;
    22
    }
    23
    
                                                    
                                                
    24
    ✓ 13
    library stdStorageSafe {
    25
        event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);
    26
        event WARNING_UninitedSlot(address who, uint256 slot);
    27
    
                                                    
                                                
    28
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    29
        uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
    30
    
                                                    
                                                
    31
        function sigs(string memory sigStr) internal pure returns (bytes4) {
    32
            return bytes4(keccak256(bytes(sigStr)));
    33
        }
    34
    
                                                    
                                                
    35
        function getCallParams(StdStorage storage self) internal view returns (bytes memory) {
    36
            if (self._calldata.length == 0) {
    37
                return flatten(self._keys);
    38
            } else {
    39
                return self._calldata;
    40
            }
    41
        }
    42
    
                                                    
                                                
    43
        // Calls target contract with configured parameters
    44
        function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {
    45
            bytes memory cd = abi.encodePacked(self._sig, getCallParams(self));
    46
            (bool success, bytes memory rdat) = self._target.staticcall(cd);
    47
            bytes32 result = bytesToBytes32(rdat, 32 * self._depth);
    48
    
                                                    
                                                
    49
            return (success, result);
    50
        }
    51
    
                                                    
                                                
    52
        // Tries mutating slot value to determine if the targeted value is stored in it.
    53
        // If current value is 0, then we are setting slot value to type(uint256).max
    54
        // Otherwise, we set it to 0. That way, return value should always be affected.
    55
        function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {
    56
            bytes32 prevSlotValue = vm.load(self._target, slot);
    57
            (bool success, bytes32 prevReturnValue) = callTarget(self);
    58
    
                                                    
                                                
    59
            bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);
    60
            vm.store(self._target, slot, testVal);
    61
    
                                                    
                                                
    62
            (, bytes32 newReturnValue) = callTarget(self);
    63
    
                                                    
                                                
    64
            vm.store(self._target, slot, prevSlotValue);
    65
    
                                                    
                                                
    66
            return (success && (prevReturnValue != newReturnValue));
    67
        }
    68
    
                                                    
                                                
    69
        // Tries setting one of the bits in slot to 1 until return value changes.
    70
        // Index of resulted bit is an offset packed slot has from left/right side
    71
        function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {
    72
            for (uint256 offset = 0; offset < 256; offset++) {
    73
                uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);
    74
                vm.store(self._target, slot, bytes32(valueToPut));
    75
    
                                                    
                                                
    76
                (bool success, bytes32 data) = callTarget(self);
    77
    
                                                    
                                                
    78
                if (success && (uint256(data) > 0)) {
    79
                    return (true, offset);
    80
                }
    81
            }
    82
            return (false, 0);
    83
        }
    84
    
                                                    
                                                
    85
        function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {
    86
            bytes32 prevSlotValue = vm.load(self._target, slot);
    87
    
                                                    
                                                
    88
            (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);
    89
            (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);
    90
    
                                                    
                                                
    91
            // `findOffset` may mutate slot value, so we are setting it to initial value
    92
            vm.store(self._target, slot, prevSlotValue);
    93
            return (foundLeft && foundRight, offsetLeft, offsetRight);
    94
        }
    95
    
                                                    
                                                
    96
        function find(StdStorage storage self) internal returns (FindData storage) {
    97
            return find(self, true);
    98
        }
    99
    
                                                    
                                                
    100
        /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against
    101
        // slot complexity:
    102
        //  if flat, will be bytes32(uint256(uint));
    103
        //  if map, will be keccak256(abi.encode(key, uint(slot)));
    104
        //  if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));
    105
        //  if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);
    106
        function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {
    107
            address who = self._target;
    108
            bytes4 fsig = self._sig;
    109
            uint256 field_depth = self._depth;
    110
            bytes memory params = getCallParams(self);
    111
    
                                                    
                                                
    112
            // calldata to test against
    113
            if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {
    114
                if (_clear) {
    115
                    clear(self);
    116
                }
    117
                return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
    118
            }
    119
            vm.record();
    120
            (, bytes32 callResult) = callTarget(self);
    121
            (bytes32[] memory reads,) = vm.accesses(address(who));
    122
    
                                                    
                                                
    123
            if (reads.length == 0) {
    124
                revert("stdStorage find(StdStorage): No storage use detected for target.");
    125
            } else {
    126
                for (uint256 i = reads.length; --i >= 0;) {
    127
                    bytes32 prev = vm.load(who, reads[i]);
    128
                    if (prev == bytes32(0)) {
    129
                        emit WARNING_UninitedSlot(who, uint256(reads[i]));
    130
                    }
    131
    
                                                    
                                                
    132
                    if (!checkSlotMutatesCall(self, reads[i])) {
    133
                        continue;
    134
                    }
    135
    
                                                    
                                                
    136
                    (uint256 offsetLeft, uint256 offsetRight) = (0, 0);
    137
    
                                                    
                                                
    138
                    if (self._enable_packed_slots) {
    139
                        bool found;
    140
                        (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);
    141
                        if (!found) {
    142
                            continue;
    143
                        }
    144
                    }
    145
    
                                                    
                                                
    146
                    // Check that value between found offsets is equal to the current call result
    147
                    uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;
    148
    
                                                    
                                                
    149
                    if (uint256(callResult) != curVal) {
    150
                        continue;
    151
                    }
    152
    
                                                    
                                                
    153
                    emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));
    154
                    self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =
    155
                        FindData(uint256(reads[i]), offsetLeft, offsetRight, true);
    156
                    break;
    157
                }
    158
            }
    159
    
                                                    
                                                
    160
            require(
    161
                self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,
    162
                "stdStorage find(StdStorage): Slot(s) not found."
    163
            );
    164
    
                                                    
                                                
    165
            if (_clear) {
    166
                clear(self);
    167
            }
    168
            return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
    169
        }
    170
    
                                                    
                                                
    171
        function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
    172
            self._target = _target;
    173
            return self;
    174
        }
    175
    
                                                    
                                                
    176
        function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
    177
            self._sig = _sig;
    178
            return self;
    179
        }
    180
    
                                                    
                                                
    181
        function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
    182
            self._sig = sigs(_sig);
    183
            return self;
    184
        }
    185
    
                                                    
                                                
    186
        function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {
    187
            self._calldata = _calldata;
    188
            return self;
    189
        }
    190
    
                                                    
                                                
    191
        function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
    192
            self._keys.push(bytes32(uint256(uint160(who))));
    193
            return self;
    194
        }
    195
    
                                                    
                                                
    196
        function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
    197
            self._keys.push(bytes32(amt));
    198
            return self;
    199
        }
    200
    
                                                    
                                                
    201
        function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
    202
            self._keys.push(key);
    203
            return self;
    204
        }
    205
    
                                                    
                                                
    206
        function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {
    207
            self._enable_packed_slots = true;
    208
            return self;
    209
        }
    210
    
                                                    
                                                
    211
        function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
    212
            self._depth = _depth;
    213
            return self;
    214
        }
    215
    
                                                    
                                                
    216
        function read(StdStorage storage self) private returns (bytes memory) {
    217
            FindData storage data = find(self, false);
    218
            uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);
    219
            uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;
    220
            clear(self);
    221
            return abi.encode(value);
    222
        }
    223
    
                                                    
                                                
    224
        function read_bytes32(StdStorage storage self) internal returns (bytes32) {
    225
            return abi.decode(read(self), (bytes32));
    226
        }
    227
    
                                                    
                                                
    228
        function read_bool(StdStorage storage self) internal returns (bool) {
    229
            int256 v = read_int(self);
    230
            if (v == 0) return false;
    231
            if (v == 1) return true;
    232
            revert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.");
    233
        }
    234
    
                                                    
                                                
    235
        function read_address(StdStorage storage self) internal returns (address) {
    236
            return abi.decode(read(self), (address));
    237
        }
    238
    
                                                    
                                                
    239
        function read_uint(StdStorage storage self) internal returns (uint256) {
    240
            return abi.decode(read(self), (uint256));
    241
        }
    242
    
                                                    
                                                
    243
        function read_int(StdStorage storage self) internal returns (int256) {
    244
            return abi.decode(read(self), (int256));
    245
        }
    246
    
                                                    
                                                
    247
        function parent(StdStorage storage self) internal returns (uint256, bytes32) {
    248
            address who = self._target;
    249
            uint256 field_depth = self._depth;
    250
            vm.startMappingRecording();
    251
            uint256 child = find(self, true).slot - field_depth;
    252
            (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
    253
            if (!found) {
    254
                revert(
    255
                    "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
    256
                );
    257
            }
    258
            return (uint256(parent_slot), key);
    259
        }
    260
    
                                                    
                                                
    261
        function root(StdStorage storage self) internal returns (uint256) {
    262
            address who = self._target;
    263
            uint256 field_depth = self._depth;
    264
            vm.startMappingRecording();
    265
            uint256 child = find(self, true).slot - field_depth;
    266
            bool found;
    267
            bytes32 root_slot;
    268
            bytes32 parent_slot;
    269
            (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
    270
            if (!found) {
    271
                revert(
    272
                    "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
    273
                );
    274
            }
    275
            while (found) {
    276
                root_slot = parent_slot;
    277
                (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));
    278
            }
    279
            return uint256(root_slot);
    280
        }
    281
    
                                                    
                                                
    282
        function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {
    283
            bytes32 out;
    284
    
                                                    
                                                
    285
            uint256 max = b.length > 32 ? 32 : b.length;
    286
            for (uint256 i = 0; i < max; i++) {
    287
                out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);
    288
            }
    289
            return out;
    290
        }
    291
    
                                                    
                                                
    292
        function flatten(bytes32[] memory b) private pure returns (bytes memory) {
    293
            bytes memory result = new bytes(b.length * 32);
    294
            for (uint256 i = 0; i < b.length; i++) {
    295
                bytes32 k = b[i];
    296
                /// @solidity memory-safe-assembly
    297
                assembly {
    298
                    mstore(add(result, add(32, mul(32, i))), k)
    299
                }
    300
            }
    301
    
                                                    
                                                
    302
            return result;
    303
        }
    304
    
                                                    
                                                
    305
        function clear(StdStorage storage self) internal {
    306
            delete self._target;
    307
            delete self._sig;
    308
            delete self._keys;
    309
            delete self._depth;
    310
            delete self._enable_packed_slots;
    311
            delete self._calldata;
    312
        }
    313
    
                                                    
                                                
    314
        // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`
    315
        // (slotValue & mask) >> offsetRight will be the value of the given packed variable
    316
        function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {
    317
            // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;
    318
            // using assembly because (1 << 256) causes overflow
    319
            assembly {
    320
                mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))
    321
            }
    322
        }
    323
    
                                                    
                                                
    324
        // Returns slot value with updated packed variable.
    325
        function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)
    326
            internal
    327
            pure
    328
            returns (bytes32 newValue)
    329
        {
    330
            return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));
    331
        }
    332
    }
    333
    
                                                    
                                                
    334
    ✓ 13
    library stdStorage {
    335
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    336
    
                                                    
                                                
    337
        function sigs(string memory sigStr) internal pure returns (bytes4) {
    338
            return stdStorageSafe.sigs(sigStr);
    339
        }
    340
    
                                                    
                                                
    341
        function find(StdStorage storage self) internal returns (uint256) {
    342
            return find(self, true);
    343
        }
    344
    
                                                    
                                                
    345
        function find(StdStorage storage self, bool _clear) internal returns (uint256) {
    346
            return stdStorageSafe.find(self, _clear).slot;
    347
        }
    348
    
                                                    
                                                
    349
        function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
    350
            return stdStorageSafe.target(self, _target);
    351
        }
    352
    
                                                    
                                                
    353
        function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
    354
            return stdStorageSafe.sig(self, _sig);
    355
        }
    356
    
                                                    
                                                
    357
        function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
    358
            return stdStorageSafe.sig(self, _sig);
    359
        }
    360
    
                                                    
                                                
    361
        function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
    362
            return stdStorageSafe.with_key(self, who);
    363
        }
    364
    
                                                    
                                                
    365
        function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
    366
            return stdStorageSafe.with_key(self, amt);
    367
        }
    368
    
                                                    
                                                
    369
        function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
    370
            return stdStorageSafe.with_key(self, key);
    371
        }
    372
    
                                                    
                                                
    373
        function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {
    374
            return stdStorageSafe.with_calldata(self, _calldata);
    375
        }
    376
    
                                                    
                                                
    377
        function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {
    378
            return stdStorageSafe.enable_packed_slots(self);
    379
        }
    380
    
                                                    
                                                
    381
        function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
    382
            return stdStorageSafe.depth(self, _depth);
    383
        }
    384
    
                                                    
                                                
    385
        function clear(StdStorage storage self) internal {
    386
            stdStorageSafe.clear(self);
    387
        }
    388
    
                                                    
                                                
    389
        function checked_write(StdStorage storage self, address who) internal {
    390
            checked_write(self, bytes32(uint256(uint160(who))));
    391
        }
    392
    
                                                    
                                                
    393
        function checked_write(StdStorage storage self, uint256 amt) internal {
    394
            checked_write(self, bytes32(amt));
    395
        }
    396
    
                                                    
                                                
    397
        function checked_write_int(StdStorage storage self, int256 val) internal {
    398
            checked_write(self, bytes32(uint256(val)));
    399
        }
    400
    
                                                    
                                                
    401
        function checked_write(StdStorage storage self, bool write) internal {
    402
            bytes32 t;
    403
            /// @solidity memory-safe-assembly
    404
            assembly {
    405
                t := write
    406
            }
    407
            checked_write(self, t);
    408
        }
    409
    
                                                    
                                                
    410
        function checked_write(StdStorage storage self, bytes32 set) internal {
    411
            address who = self._target;
    412
            bytes4 fsig = self._sig;
    413
            uint256 field_depth = self._depth;
    414
            bytes memory params = stdStorageSafe.getCallParams(self);
    415
    
                                                    
                                                
    416
            if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {
    417
                find(self, false);
    418
            }
    419
            FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
    420
            if ((data.offsetLeft + data.offsetRight) > 0) {
    421
                uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));
    422
                require(
    423
                    uint256(set) < maxVal,
    424
                    string(
    425
                        abi.encodePacked(
    426
                            "stdStorage find(StdStorage): Packed slot. We can't fit value greater than ",
    427
                            vm.toString(maxVal)
    428
                        )
    429
                    )
    430
                );
    431
            }
    432
            bytes32 curVal = vm.load(who, bytes32(data.slot));
    433
            bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);
    434
    
                                                    
                                                
    435
            vm.store(who, bytes32(data.slot), valToSet);
    436
    
                                                    
                                                
    437
            (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);
    438
    
                                                    
                                                
    439
            if (!success || callResult != set) {
    440
                vm.store(who, bytes32(data.slot), curVal);
    441
                revert("stdStorage find(StdStorage): Failed to write value.");
    442
            }
    443
            clear(self);
    444
        }
    445
    
                                                    
                                                
    446
        function read_bytes32(StdStorage storage self) internal returns (bytes32) {
    447
            return stdStorageSafe.read_bytes32(self);
    448
        }
    449
    
                                                    
                                                
    450
        function read_bool(StdStorage storage self) internal returns (bool) {
    451
            return stdStorageSafe.read_bool(self);
    452
        }
    453
    
                                                    
                                                
    454
        function read_address(StdStorage storage self) internal returns (address) {
    455
            return stdStorageSafe.read_address(self);
    456
        }
    457
    
                                                    
                                                
    458
        function read_uint(StdStorage storage self) internal returns (uint256) {
    459
            return stdStorageSafe.read_uint(self);
    460
        }
    461
    
                                                    
                                                
    462
        function read_int(StdStorage storage self) internal returns (int256) {
    463
            return stdStorageSafe.read_int(self);
    464
        }
    465
    
                                                    
                                                
    466
        function parent(StdStorage storage self) internal returns (uint256, bytes32) {
    467
            return stdStorageSafe.parent(self);
    468
        }
    469
    
                                                    
                                                
    470
        function root(StdStorage storage self) internal returns (uint256) {
    471
            return stdStorageSafe.root(self);
    472
        }
    473
    }
    474
    
                                                    
                                                
    100.0% lib/forge-std/src/StdStyle.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.4.22 <0.9.0;
    3
    
                                                    
                                                
    4
    import {VmSafe} from "./Vm.sol";
    5
    
                                                    
                                                
    6
    ✓ 13
    library StdStyle {
    7
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    8
    
                                                    
                                                
    9
        string constant RED = "\u001b[91m";
    10
        string constant GREEN = "\u001b[92m";
    11
        string constant YELLOW = "\u001b[93m";
    12
        string constant BLUE = "\u001b[94m";
    13
        string constant MAGENTA = "\u001b[95m";
    14
        string constant CYAN = "\u001b[96m";
    15
        string constant BOLD = "\u001b[1m";
    16
        string constant DIM = "\u001b[2m";
    17
        string constant ITALIC = "\u001b[3m";
    18
        string constant UNDERLINE = "\u001b[4m";
    19
        string constant INVERSE = "\u001b[7m";
    20
        string constant RESET = "\u001b[0m";
    21
    
                                                    
                                                
    22
        function styleConcat(string memory style, string memory self) private pure returns (string memory) {
    23
            return string(abi.encodePacked(style, self, RESET));
    24
        }
    25
    
                                                    
                                                
    26
        function red(string memory self) internal pure returns (string memory) {
    27
            return styleConcat(RED, self);
    28
        }
    29
    
                                                    
                                                
    30
        function red(uint256 self) internal pure returns (string memory) {
    31
            return red(vm.toString(self));
    32
        }
    33
    
                                                    
                                                
    34
        function red(int256 self) internal pure returns (string memory) {
    35
            return red(vm.toString(self));
    36
        }
    37
    
                                                    
                                                
    38
        function red(address self) internal pure returns (string memory) {
    39
            return red(vm.toString(self));
    40
        }
    41
    
                                                    
                                                
    42
        function red(bool self) internal pure returns (string memory) {
    43
            return red(vm.toString(self));
    44
        }
    45
    
                                                    
                                                
    46
        function redBytes(bytes memory self) internal pure returns (string memory) {
    47
            return red(vm.toString(self));
    48
        }
    49
    
                                                    
                                                
    50
        function redBytes32(bytes32 self) internal pure returns (string memory) {
    51
            return red(vm.toString(self));
    52
        }
    53
    
                                                    
                                                
    54
        function green(string memory self) internal pure returns (string memory) {
    55
            return styleConcat(GREEN, self);
    56
        }
    57
    
                                                    
                                                
    58
        function green(uint256 self) internal pure returns (string memory) {
    59
            return green(vm.toString(self));
    60
        }
    61
    
                                                    
                                                
    62
        function green(int256 self) internal pure returns (string memory) {
    63
            return green(vm.toString(self));
    64
        }
    65
    
                                                    
                                                
    66
        function green(address self) internal pure returns (string memory) {
    67
            return green(vm.toString(self));
    68
        }
    69
    
                                                    
                                                
    70
        function green(bool self) internal pure returns (string memory) {
    71
            return green(vm.toString(self));
    72
        }
    73
    
                                                    
                                                
    74
        function greenBytes(bytes memory self) internal pure returns (string memory) {
    75
            return green(vm.toString(self));
    76
        }
    77
    
                                                    
                                                
    78
        function greenBytes32(bytes32 self) internal pure returns (string memory) {
    79
            return green(vm.toString(self));
    80
        }
    81
    
                                                    
                                                
    82
        function yellow(string memory self) internal pure returns (string memory) {
    83
            return styleConcat(YELLOW, self);
    84
        }
    85
    
                                                    
                                                
    86
        function yellow(uint256 self) internal pure returns (string memory) {
    87
            return yellow(vm.toString(self));
    88
        }
    89
    
                                                    
                                                
    90
        function yellow(int256 self) internal pure returns (string memory) {
    91
            return yellow(vm.toString(self));
    92
        }
    93
    
                                                    
                                                
    94
        function yellow(address self) internal pure returns (string memory) {
    95
            return yellow(vm.toString(self));
    96
        }
    97
    
                                                    
                                                
    98
        function yellow(bool self) internal pure returns (string memory) {
    99
            return yellow(vm.toString(self));
    100
        }
    101
    
                                                    
                                                
    102
        function yellowBytes(bytes memory self) internal pure returns (string memory) {
    103
            return yellow(vm.toString(self));
    104
        }
    105
    
                                                    
                                                
    106
        function yellowBytes32(bytes32 self) internal pure returns (string memory) {
    107
            return yellow(vm.toString(self));
    108
        }
    109
    
                                                    
                                                
    110
        function blue(string memory self) internal pure returns (string memory) {
    111
            return styleConcat(BLUE, self);
    112
        }
    113
    
                                                    
                                                
    114
        function blue(uint256 self) internal pure returns (string memory) {
    115
            return blue(vm.toString(self));
    116
        }
    117
    
                                                    
                                                
    118
        function blue(int256 self) internal pure returns (string memory) {
    119
            return blue(vm.toString(self));
    120
        }
    121
    
                                                    
                                                
    122
        function blue(address self) internal pure returns (string memory) {
    123
            return blue(vm.toString(self));
    124
        }
    125
    
                                                    
                                                
    126
        function blue(bool self) internal pure returns (string memory) {
    127
            return blue(vm.toString(self));
    128
        }
    129
    
                                                    
                                                
    130
        function blueBytes(bytes memory self) internal pure returns (string memory) {
    131
            return blue(vm.toString(self));
    132
        }
    133
    
                                                    
                                                
    134
        function blueBytes32(bytes32 self) internal pure returns (string memory) {
    135
            return blue(vm.toString(self));
    136
        }
    137
    
                                                    
                                                
    138
        function magenta(string memory self) internal pure returns (string memory) {
    139
            return styleConcat(MAGENTA, self);
    140
        }
    141
    
                                                    
                                                
    142
        function magenta(uint256 self) internal pure returns (string memory) {
    143
            return magenta(vm.toString(self));
    144
        }
    145
    
                                                    
                                                
    146
        function magenta(int256 self) internal pure returns (string memory) {
    147
            return magenta(vm.toString(self));
    148
        }
    149
    
                                                    
                                                
    150
        function magenta(address self) internal pure returns (string memory) {
    151
            return magenta(vm.toString(self));
    152
        }
    153
    
                                                    
                                                
    154
        function magenta(bool self) internal pure returns (string memory) {
    155
            return magenta(vm.toString(self));
    156
        }
    157
    
                                                    
                                                
    158
        function magentaBytes(bytes memory self) internal pure returns (string memory) {
    159
            return magenta(vm.toString(self));
    160
        }
    161
    
                                                    
                                                
    162
        function magentaBytes32(bytes32 self) internal pure returns (string memory) {
    163
            return magenta(vm.toString(self));
    164
        }
    165
    
                                                    
                                                
    166
        function cyan(string memory self) internal pure returns (string memory) {
    167
            return styleConcat(CYAN, self);
    168
        }
    169
    
                                                    
                                                
    170
        function cyan(uint256 self) internal pure returns (string memory) {
    171
            return cyan(vm.toString(self));
    172
        }
    173
    
                                                    
                                                
    174
        function cyan(int256 self) internal pure returns (string memory) {
    175
            return cyan(vm.toString(self));
    176
        }
    177
    
                                                    
                                                
    178
        function cyan(address self) internal pure returns (string memory) {
    179
            return cyan(vm.toString(self));
    180
        }
    181
    
                                                    
                                                
    182
        function cyan(bool self) internal pure returns (string memory) {
    183
            return cyan(vm.toString(self));
    184
        }
    185
    
                                                    
                                                
    186
        function cyanBytes(bytes memory self) internal pure returns (string memory) {
    187
            return cyan(vm.toString(self));
    188
        }
    189
    
                                                    
                                                
    190
        function cyanBytes32(bytes32 self) internal pure returns (string memory) {
    191
            return cyan(vm.toString(self));
    192
        }
    193
    
                                                    
                                                
    194
        function bold(string memory self) internal pure returns (string memory) {
    195
            return styleConcat(BOLD, self);
    196
        }
    197
    
                                                    
                                                
    198
        function bold(uint256 self) internal pure returns (string memory) {
    199
            return bold(vm.toString(self));
    200
        }
    201
    
                                                    
                                                
    202
        function bold(int256 self) internal pure returns (string memory) {
    203
            return bold(vm.toString(self));
    204
        }
    205
    
                                                    
                                                
    206
        function bold(address self) internal pure returns (string memory) {
    207
            return bold(vm.toString(self));
    208
        }
    209
    
                                                    
                                                
    210
        function bold(bool self) internal pure returns (string memory) {
    211
            return bold(vm.toString(self));
    212
        }
    213
    
                                                    
                                                
    214
        function boldBytes(bytes memory self) internal pure returns (string memory) {
    215
            return bold(vm.toString(self));
    216
        }
    217
    
                                                    
                                                
    218
        function boldBytes32(bytes32 self) internal pure returns (string memory) {
    219
            return bold(vm.toString(self));
    220
        }
    221
    
                                                    
                                                
    222
        function dim(string memory self) internal pure returns (string memory) {
    223
            return styleConcat(DIM, self);
    224
        }
    225
    
                                                    
                                                
    226
        function dim(uint256 self) internal pure returns (string memory) {
    227
            return dim(vm.toString(self));
    228
        }
    229
    
                                                    
                                                
    230
        function dim(int256 self) internal pure returns (string memory) {
    231
            return dim(vm.toString(self));
    232
        }
    233
    
                                                    
                                                
    234
        function dim(address self) internal pure returns (string memory) {
    235
            return dim(vm.toString(self));
    236
        }
    237
    
                                                    
                                                
    238
        function dim(bool self) internal pure returns (string memory) {
    239
            return dim(vm.toString(self));
    240
        }
    241
    
                                                    
                                                
    242
        function dimBytes(bytes memory self) internal pure returns (string memory) {
    243
            return dim(vm.toString(self));
    244
        }
    245
    
                                                    
                                                
    246
        function dimBytes32(bytes32 self) internal pure returns (string memory) {
    247
            return dim(vm.toString(self));
    248
        }
    249
    
                                                    
                                                
    250
        function italic(string memory self) internal pure returns (string memory) {
    251
            return styleConcat(ITALIC, self);
    252
        }
    253
    
                                                    
                                                
    254
        function italic(uint256 self) internal pure returns (string memory) {
    255
            return italic(vm.toString(self));
    256
        }
    257
    
                                                    
                                                
    258
        function italic(int256 self) internal pure returns (string memory) {
    259
            return italic(vm.toString(self));
    260
        }
    261
    
                                                    
                                                
    262
        function italic(address self) internal pure returns (string memory) {
    263
            return italic(vm.toString(self));
    264
        }
    265
    
                                                    
                                                
    266
        function italic(bool self) internal pure returns (string memory) {
    267
            return italic(vm.toString(self));
    268
        }
    269
    
                                                    
                                                
    270
        function italicBytes(bytes memory self) internal pure returns (string memory) {
    271
            return italic(vm.toString(self));
    272
        }
    273
    
                                                    
                                                
    274
        function italicBytes32(bytes32 self) internal pure returns (string memory) {
    275
            return italic(vm.toString(self));
    276
        }
    277
    
                                                    
                                                
    278
        function underline(string memory self) internal pure returns (string memory) {
    279
            return styleConcat(UNDERLINE, self);
    280
        }
    281
    
                                                    
                                                
    282
        function underline(uint256 self) internal pure returns (string memory) {
    283
            return underline(vm.toString(self));
    284
        }
    285
    
                                                    
                                                
    286
        function underline(int256 self) internal pure returns (string memory) {
    287
            return underline(vm.toString(self));
    288
        }
    289
    
                                                    
                                                
    290
        function underline(address self) internal pure returns (string memory) {
    291
            return underline(vm.toString(self));
    292
        }
    293
    
                                                    
                                                
    294
        function underline(bool self) internal pure returns (string memory) {
    295
            return underline(vm.toString(self));
    296
        }
    297
    
                                                    
                                                
    298
        function underlineBytes(bytes memory self) internal pure returns (string memory) {
    299
            return underline(vm.toString(self));
    300
        }
    301
    
                                                    
                                                
    302
        function underlineBytes32(bytes32 self) internal pure returns (string memory) {
    303
            return underline(vm.toString(self));
    304
        }
    305
    
                                                    
                                                
    306
        function inverse(string memory self) internal pure returns (string memory) {
    307
            return styleConcat(INVERSE, self);
    308
        }
    309
    
                                                    
                                                
    310
        function inverse(uint256 self) internal pure returns (string memory) {
    311
            return inverse(vm.toString(self));
    312
        }
    313
    
                                                    
                                                
    314
        function inverse(int256 self) internal pure returns (string memory) {
    315
            return inverse(vm.toString(self));
    316
        }
    317
    
                                                    
                                                
    318
        function inverse(address self) internal pure returns (string memory) {
    319
            return inverse(vm.toString(self));
    320
        }
    321
    
                                                    
                                                
    322
        function inverse(bool self) internal pure returns (string memory) {
    323
            return inverse(vm.toString(self));
    324
        }
    325
    
                                                    
                                                
    326
        function inverseBytes(bytes memory self) internal pure returns (string memory) {
    327
            return inverse(vm.toString(self));
    328
        }
    329
    
                                                    
                                                
    330
        function inverseBytes32(bytes32 self) internal pure returns (string memory) {
    331
            return inverse(vm.toString(self));
    332
        }
    333
    }
    334
    
                                                    
                                                
    100.0% lib/forge-std/src/StdToml.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.0 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    import {VmSafe} from "./Vm.sol";
    7
    
                                                    
                                                
    8
    // Helpers for parsing and writing TOML files
    9
    // To parse:
    10
    // ```
    11
    // using stdToml for string;
    12
    // string memory toml = vm.readFile("<some_path>");
    13
    // toml.readUint("<json_path>");
    14
    // ```
    15
    // To write:
    16
    // ```
    17
    // using stdToml for string;
    18
    // string memory json = "json";
    19
    // json.serialize("a", uint256(123));
    20
    // string memory semiFinal = json.serialize("b", string("test"));
    21
    // string memory finalJson = json.serialize("c", semiFinal);
    22
    // finalJson.write("<some_path>");
    23
    // ```
    24
    
                                                    
                                                
    25
    ✓ 13
    library stdToml {
    26
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    27
    
                                                    
                                                
    28
        function keyExists(string memory toml, string memory key) internal view returns (bool) {
    29
            return vm.keyExistsToml(toml, key);
    30
        }
    31
    
                                                    
                                                
    32
        function parseRaw(string memory toml, string memory key) internal pure returns (bytes memory) {
    33
            return vm.parseToml(toml, key);
    34
        }
    35
    
                                                    
                                                
    36
        function readUint(string memory toml, string memory key) internal pure returns (uint256) {
    37
            return vm.parseTomlUint(toml, key);
    38
        }
    39
    
                                                    
                                                
    40
        function readUintArray(string memory toml, string memory key) internal pure returns (uint256[] memory) {
    41
            return vm.parseTomlUintArray(toml, key);
    42
        }
    43
    
                                                    
                                                
    44
        function readInt(string memory toml, string memory key) internal pure returns (int256) {
    45
            return vm.parseTomlInt(toml, key);
    46
        }
    47
    
                                                    
                                                
    48
        function readIntArray(string memory toml, string memory key) internal pure returns (int256[] memory) {
    49
            return vm.parseTomlIntArray(toml, key);
    50
        }
    51
    
                                                    
                                                
    52
        function readBytes32(string memory toml, string memory key) internal pure returns (bytes32) {
    53
            return vm.parseTomlBytes32(toml, key);
    54
        }
    55
    
                                                    
                                                
    56
        function readBytes32Array(string memory toml, string memory key) internal pure returns (bytes32[] memory) {
    57
            return vm.parseTomlBytes32Array(toml, key);
    58
        }
    59
    
                                                    
                                                
    60
        function readString(string memory toml, string memory key) internal pure returns (string memory) {
    61
            return vm.parseTomlString(toml, key);
    62
        }
    63
    
                                                    
                                                
    64
        function readStringArray(string memory toml, string memory key) internal pure returns (string[] memory) {
    65
            return vm.parseTomlStringArray(toml, key);
    66
        }
    67
    
                                                    
                                                
    68
        function readAddress(string memory toml, string memory key) internal pure returns (address) {
    69
            return vm.parseTomlAddress(toml, key);
    70
        }
    71
    
                                                    
                                                
    72
        function readAddressArray(string memory toml, string memory key) internal pure returns (address[] memory) {
    73
            return vm.parseTomlAddressArray(toml, key);
    74
        }
    75
    
                                                    
                                                
    76
        function readBool(string memory toml, string memory key) internal pure returns (bool) {
    77
            return vm.parseTomlBool(toml, key);
    78
        }
    79
    
                                                    
                                                
    80
        function readBoolArray(string memory toml, string memory key) internal pure returns (bool[] memory) {
    81
            return vm.parseTomlBoolArray(toml, key);
    82
        }
    83
    
                                                    
                                                
    84
        function readBytes(string memory toml, string memory key) internal pure returns (bytes memory) {
    85
            return vm.parseTomlBytes(toml, key);
    86
        }
    87
    
                                                    
                                                
    88
        function readBytesArray(string memory toml, string memory key) internal pure returns (bytes[] memory) {
    89
            return vm.parseTomlBytesArray(toml, key);
    90
        }
    91
    
                                                    
                                                
    92
        function readUintOr(string memory toml, string memory key, uint256 defaultValue) internal view returns (uint256) {
    93
            return keyExists(toml, key) ? readUint(toml, key) : defaultValue;
    94
        }
    95
    
                                                    
                                                
    96
        function readUintArrayOr(string memory toml, string memory key, uint256[] memory defaultValue)
    97
            internal
    98
            view
    99
            returns (uint256[] memory)
    100
        {
    101
            return keyExists(toml, key) ? readUintArray(toml, key) : defaultValue;
    102
        }
    103
    
                                                    
                                                
    104
        function readIntOr(string memory toml, string memory key, int256 defaultValue) internal view returns (int256) {
    105
            return keyExists(toml, key) ? readInt(toml, key) : defaultValue;
    106
        }
    107
    
                                                    
                                                
    108
        function readIntArrayOr(string memory toml, string memory key, int256[] memory defaultValue)
    109
            internal
    110
            view
    111
            returns (int256[] memory)
    112
        {
    113
            return keyExists(toml, key) ? readIntArray(toml, key) : defaultValue;
    114
        }
    115
    
                                                    
                                                
    116
        function readBytes32Or(string memory toml, string memory key, bytes32 defaultValue)
    117
            internal
    118
            view
    119
            returns (bytes32)
    120
        {
    121
            return keyExists(toml, key) ? readBytes32(toml, key) : defaultValue;
    122
        }
    123
    
                                                    
                                                
    124
        function readBytes32ArrayOr(string memory toml, string memory key, bytes32[] memory defaultValue)
    125
            internal
    126
            view
    127
            returns (bytes32[] memory)
    128
        {
    129
            return keyExists(toml, key) ? readBytes32Array(toml, key) : defaultValue;
    130
        }
    131
    
                                                    
                                                
    132
        function readStringOr(string memory toml, string memory key, string memory defaultValue)
    133
            internal
    134
            view
    135
            returns (string memory)
    136
        {
    137
            return keyExists(toml, key) ? readString(toml, key) : defaultValue;
    138
        }
    139
    
                                                    
                                                
    140
        function readStringArrayOr(string memory toml, string memory key, string[] memory defaultValue)
    141
            internal
    142
            view
    143
            returns (string[] memory)
    144
        {
    145
            return keyExists(toml, key) ? readStringArray(toml, key) : defaultValue;
    146
        }
    147
    
                                                    
                                                
    148
        function readAddressOr(string memory toml, string memory key, address defaultValue)
    149
            internal
    150
            view
    151
            returns (address)
    152
        {
    153
            return keyExists(toml, key) ? readAddress(toml, key) : defaultValue;
    154
        }
    155
    
                                                    
                                                
    156
        function readAddressArrayOr(string memory toml, string memory key, address[] memory defaultValue)
    157
            internal
    158
            view
    159
            returns (address[] memory)
    160
        {
    161
            return keyExists(toml, key) ? readAddressArray(toml, key) : defaultValue;
    162
        }
    163
    
                                                    
                                                
    164
        function readBoolOr(string memory toml, string memory key, bool defaultValue) internal view returns (bool) {
    165
            return keyExists(toml, key) ? readBool(toml, key) : defaultValue;
    166
        }
    167
    
                                                    
                                                
    168
        function readBoolArrayOr(string memory toml, string memory key, bool[] memory defaultValue)
    169
            internal
    170
            view
    171
            returns (bool[] memory)
    172
        {
    173
            return keyExists(toml, key) ? readBoolArray(toml, key) : defaultValue;
    174
        }
    175
    
                                                    
                                                
    176
        function readBytesOr(string memory toml, string memory key, bytes memory defaultValue)
    177
            internal
    178
            view
    179
            returns (bytes memory)
    180
        {
    181
            return keyExists(toml, key) ? readBytes(toml, key) : defaultValue;
    182
        }
    183
    
                                                    
                                                
    184
        function readBytesArrayOr(string memory toml, string memory key, bytes[] memory defaultValue)
    185
            internal
    186
            view
    187
            returns (bytes[] memory)
    188
        {
    189
            return keyExists(toml, key) ? readBytesArray(toml, key) : defaultValue;
    190
        }
    191
    
                                                    
                                                
    192
        function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
    193
            return vm.serializeJson(jsonKey, rootObject);
    194
        }
    195
    
                                                    
                                                
    196
        function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
    197
            return vm.serializeBool(jsonKey, key, value);
    198
        }
    199
    
                                                    
                                                
    200
        function serialize(string memory jsonKey, string memory key, bool[] memory value)
    201
            internal
    202
            returns (string memory)
    203
        {
    204
            return vm.serializeBool(jsonKey, key, value);
    205
        }
    206
    
                                                    
                                                
    207
        function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
    208
            return vm.serializeUint(jsonKey, key, value);
    209
        }
    210
    
                                                    
                                                
    211
        function serialize(string memory jsonKey, string memory key, uint256[] memory value)
    212
            internal
    213
            returns (string memory)
    214
        {
    215
            return vm.serializeUint(jsonKey, key, value);
    216
        }
    217
    
                                                    
                                                
    218
        function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
    219
            return vm.serializeInt(jsonKey, key, value);
    220
        }
    221
    
                                                    
                                                
    222
        function serialize(string memory jsonKey, string memory key, int256[] memory value)
    223
            internal
    224
            returns (string memory)
    225
        {
    226
            return vm.serializeInt(jsonKey, key, value);
    227
        }
    228
    
                                                    
                                                
    229
        function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
    230
            return vm.serializeAddress(jsonKey, key, value);
    231
        }
    232
    
                                                    
                                                
    233
        function serialize(string memory jsonKey, string memory key, address[] memory value)
    234
            internal
    235
            returns (string memory)
    236
        {
    237
            return vm.serializeAddress(jsonKey, key, value);
    238
        }
    239
    
                                                    
                                                
    240
        function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
    241
            return vm.serializeBytes32(jsonKey, key, value);
    242
        }
    243
    
                                                    
                                                
    244
        function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
    245
            internal
    246
            returns (string memory)
    247
        {
    248
            return vm.serializeBytes32(jsonKey, key, value);
    249
        }
    250
    
                                                    
                                                
    251
        function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
    252
            return vm.serializeBytes(jsonKey, key, value);
    253
        }
    254
    
                                                    
                                                
    255
        function serialize(string memory jsonKey, string memory key, bytes[] memory value)
    256
            internal
    257
            returns (string memory)
    258
        {
    259
            return vm.serializeBytes(jsonKey, key, value);
    260
        }
    261
    
                                                    
                                                
    262
        function serialize(string memory jsonKey, string memory key, string memory value)
    263
            internal
    264
            returns (string memory)
    265
        {
    266
            return vm.serializeString(jsonKey, key, value);
    267
        }
    268
    
                                                    
                                                
    269
        function serialize(string memory jsonKey, string memory key, string[] memory value)
    270
            internal
    271
            returns (string memory)
    272
        {
    273
            return vm.serializeString(jsonKey, key, value);
    274
        }
    275
    
                                                    
                                                
    276
        function write(string memory jsonKey, string memory path) internal {
    277
            vm.writeToml(jsonKey, path);
    278
        }
    279
    
                                                    
                                                
    280
        function write(string memory jsonKey, string memory path, string memory valueKey) internal {
    281
            vm.writeToml(jsonKey, path, valueKey);
    282
        }
    283
    }
    284
    
                                                    
                                                
    0.0% lib/forge-std/src/StdUtils.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    import {IMulticall3} from "./interfaces/IMulticall3.sol";
    7
    import {VmSafe} from "./Vm.sol";
    8
    
                                                    
                                                
    9
    abstract contract StdUtils {
    10
        /*//////////////////////////////////////////////////////////////////////////
    11
                                         CONSTANTS
    12
        //////////////////////////////////////////////////////////////////////////*/
    13
    
                                                    
                                                
    14
        IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);
    15
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    16
        address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
    17
        uint256 private constant INT256_MIN_ABS =
    18
            57896044618658097711785492504343953926634992332820282019728792003956564819968;
    19
        uint256 private constant SECP256K1_ORDER =
    20
            115792089237316195423570985008687907852837564279074904382605163141518161494337;
    21
        uint256 private constant UINT256_MAX =
    22
            115792089237316195423570985008687907853269984665640564039457584007913129639935;
    23
    
                                                    
                                                
    24
        // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.
    25
        address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
    26
    
                                                    
                                                
    27
        /*//////////////////////////////////////////////////////////////////////////
    28
                                     INTERNAL FUNCTIONS
    29
        //////////////////////////////////////////////////////////////////////////*/
    30
    
                                                    
                                                
    31
        function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
    32
            require(min <= max, "StdUtils bound(uint256,uint256,uint256): Max is less than min.");
    33
            // If x is between min and max, return x directly. This is to ensure that dictionary values
    34
            // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188
    35
            if (x >= min && x <= max) return x;
    36
    
                                                    
                                                
    37
            uint256 size = max - min + 1;
    38
    
                                                    
                                                
    39
            // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.
    40
            // This helps ensure coverage of the min/max values.
    41
            if (x <= 3 && size > x) return min + x;
    42
            if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);
    43
    
                                                    
                                                
    44
            // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.
    45
            if (x > max) {
    46
                uint256 diff = x - max;
    47
                uint256 rem = diff % size;
    48
                if (rem == 0) return max;
    49
                result = min + rem - 1;
    50
            } else if (x < min) {
    51
                uint256 diff = min - x;
    52
                uint256 rem = diff % size;
    53
                if (rem == 0) return min;
    54
                result = max - rem + 1;
    55
            }
    56
        }
    57
    
                                                    
                                                
    58
        function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
    59
            result = _bound(x, min, max);
    60
            console2_log_StdUtils("Bound result", result);
    61
        }
    62
    
                                                    
                                                
    63
        function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
    64
            require(min <= max, "StdUtils bound(int256,int256,int256): Max is less than min.");
    65
    
                                                    
                                                
    66
            // Shifting all int256 values to uint256 to use _bound function. The range of two types are:
    67
            // int256 : -(2**255) ~ (2**255 - 1)
    68
            // uint256:     0     ~ (2**256 - 1)
    69
            // So, add 2**255, INT256_MIN_ABS to the integer values.
    70
            //
    71
            // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.
    72
            // So, use `~uint256(x) + 1` instead.
    73
            uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);
    74
            uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);
    75
            uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);
    76
    
                                                    
                                                
    77
            uint256 y = _bound(_x, _min, _max);
    78
    
                                                    
                                                
    79
            // To move it back to int256 value, subtract INT256_MIN_ABS at here.
    80
            result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);
    81
        }
    82
    
                                                    
                                                
    83
        function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
    84
            result = _bound(x, min, max);
    85
            console2_log_StdUtils("Bound result", vm.toString(result));
    86
        }
    87
    
                                                    
                                                
    88
        function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {
    89
            result = _bound(privateKey, 1, SECP256K1_ORDER - 1);
    90
        }
    91
    
                                                    
                                                
    92
        function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {
    93
            require(b.length <= 32, "StdUtils bytesToUint(bytes): Bytes length exceeds 32.");
    94
            return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
    95
        }
    96
    
                                                    
                                                
    97
        /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce
    98
        function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {
    99
            console2_log_StdUtils("computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.");
    100
            return vm.computeCreateAddress(deployer, nonce);
    101
        }
    102
    
                                                    
                                                
    103
        function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)
    104
            internal
    105
            pure
    106
            virtual
    107
            returns (address)
    108
        {
    109
            console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
    110
            return vm.computeCreate2Address(salt, initcodeHash, deployer);
    111
        }
    112
    
                                                    
                                                
    113
        /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer
    114
        function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {
    115
            console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
    116
            return vm.computeCreate2Address(salt, initCodeHash);
    117
        }
    118
    
                                                    
                                                
    119
        /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments
    120
        /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode
    121
        function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {
    122
            return hashInitCode(creationCode, "");
    123
        }
    124
    
                                                    
                                                
    125
        /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2
    126
        /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode
    127
        /// @param args the ABI-encoded arguments to the constructor of C
    128
        function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {
    129
            return keccak256(abi.encodePacked(creationCode, args));
    130
        }
    131
    
                                                    
                                                
    132
        // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.
    133
        function getTokenBalances(address token, address[] memory addresses)
    134
            internal
    135
            virtual
    136
            returns (uint256[] memory balances)
    137
        {
    138
            uint256 tokenCodeSize;
    139
            assembly {
    140
                tokenCodeSize := extcodesize(token)
    141
            }
    142
            require(tokenCodeSize > 0, "StdUtils getTokenBalances(address,address[]): Token address is not a contract.");
    143
    
                                                    
                                                
    144
            // ABI encode the aggregate call to Multicall3.
    145
            uint256 length = addresses.length;
    146
            IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);
    147
            for (uint256 i = 0; i < length; ++i) {
    148
                // 0x70a08231 = bytes4("balanceOf(address)"))
    149
                calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});
    150
            }
    151
    
                                                    
                                                
    152
            // Make the aggregate call.
    153
            (, bytes[] memory returnData) = multicall.aggregate(calls);
    154
    
                                                    
                                                
    155
            // ABI decode the return data and return the balances.
    156
            balances = new uint256[](length);
    157
            for (uint256 i = 0; i < length; ++i) {
    158
                balances[i] = abi.decode(returnData[i], (uint256));
    159
            }
    160
        }
    161
    
                                                    
                                                
    162
        /*//////////////////////////////////////////////////////////////////////////
    163
                                     PRIVATE FUNCTIONS
    164
        //////////////////////////////////////////////////////////////////////////*/
    165
    
                                                    
                                                
    166
        function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {
    167
            return address(uint160(uint256(bytesValue)));
    168
        }
    169
    
                                                    
                                                
    170
        // This section is used to prevent the compilation of console, which shortens the compilation time when console is
    171
        // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid
    172
        // any breaking changes to function signatures.
    173
        function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)
    174
            internal
    175
            pure
    176
            returns (function(bytes memory) internal pure fnOut)
    177
        {
    178
            assembly {
    179
                fnOut := fnIn
    180
            }
    181
        }
    182
    
                                                    
                                                
    183
        function _sendLogPayload(bytes memory payload) internal pure {
    184
            _castLogPayloadViewToPure(_sendLogPayloadView)(payload);
    185
        }
    186
    
                                                    
                                                
    187
        function _sendLogPayloadView(bytes memory payload) private view {
    188
            uint256 payloadLength = payload.length;
    189
            address consoleAddress = CONSOLE2_ADDRESS;
    190
            /// @solidity memory-safe-assembly
    191
            assembly {
    192
                let payloadStart := add(payload, 32)
    193
                let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
    194
            }
    195
        }
    196
    
                                                    
                                                
    197
        function console2_log_StdUtils(string memory p0) private pure {
    198
            _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    199
        }
    200
    
                                                    
                                                
    201
        function console2_log_StdUtils(string memory p0, uint256 p1) private pure {
    202
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
    203
        }
    204
    
                                                    
                                                
    205
        function console2_log_StdUtils(string memory p0, string memory p1) private pure {
    206
            _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
    207
        }
    208
    }
    209
    
                                                    
                                                
    0.0% lib/forge-std/src/Test.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    // 💬 ABOUT
    7
    // Forge Std's default Test.
    8
    
                                                    
                                                
    9
    // 🧩 MODULES
    10
    import {console} from "./console.sol";
    11
    import {console2} from "./console2.sol";
    12
    import {safeconsole} from "./safeconsole.sol";
    13
    import {StdAssertions} from "./StdAssertions.sol";
    14
    import {StdChains} from "./StdChains.sol";
    15
    import {StdCheats} from "./StdCheats.sol";
    16
    import {StdConstants} from "./StdConstants.sol";
    17
    import {stdError} from "./StdError.sol";
    18
    import {StdInvariant} from "./StdInvariant.sol";
    19
    import {stdJson} from "./StdJson.sol";
    20
    import {stdMath} from "./StdMath.sol";
    21
    import {StdStorage, stdStorage} from "./StdStorage.sol";
    22
    import {StdStyle} from "./StdStyle.sol";
    23
    import {stdToml} from "./StdToml.sol";
    24
    import {StdUtils} from "./StdUtils.sol";
    25
    import {Vm} from "./Vm.sol";
    26
    
                                                    
                                                
    27
    // 📦 BOILERPLATE
    28
    import {TestBase} from "./Base.sol";
    29
    
                                                    
                                                
    30
    // ⭐️ TEST
    31
    abstract contract Test is TestBase, StdAssertions, StdChains, StdCheats, StdInvariant, StdUtils {
    32
        // Note: IS_TEST() must return true.
    33
        bool public IS_TEST = true;
    34
    }
    35
    
                                                    
                                                
    0.0% lib/forge-std/src/Vm.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // Automatically @generated by scripts/vm.py. Do not modify manually.
    2
    
                                                    
                                                
    3
    // SPDX-License-Identifier: MIT OR Apache-2.0
    4
    pragma solidity >=0.6.2 <0.9.0;
    5
    pragma experimental ABIEncoderV2;
    6
    
                                                    
                                                
    7
    /// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may
    8
    /// result in Script simulations differing from on-chain execution. It is recommended to only use
    9
    /// these cheats in scripts.
    10
    interface VmSafe {
    11
        /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.
    12
        enum CallerMode {
    13
            // No caller modification is currently active.
    14
            None,
    15
            // A one time broadcast triggered by a `vm.broadcast()` call is currently active.
    16
            Broadcast,
    17
            // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.
    18
            RecurrentBroadcast,
    19
            // A one time prank triggered by a `vm.prank()` call is currently active.
    20
            Prank,
    21
            // A recurrent prank triggered by a `vm.startPrank()` call is currently active.
    22
            RecurrentPrank
    23
        }
    24
    
                                                    
                                                
    25
        /// The kind of account access that occurred.
    26
        enum AccountAccessKind {
    27
            // The account was called.
    28
            Call,
    29
            // The account was called via delegatecall.
    30
            DelegateCall,
    31
            // The account was called via callcode.
    32
            CallCode,
    33
            // The account was called via staticcall.
    34
            StaticCall,
    35
            // The account was created.
    36
            Create,
    37
            // The account was selfdestructed.
    38
            SelfDestruct,
    39
            // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).
    40
            Resume,
    41
            // The account's balance was read.
    42
            Balance,
    43
            // The account's codesize was read.
    44
            Extcodesize,
    45
            // The account's codehash was read.
    46
            Extcodehash,
    47
            // The account's code was copied.
    48
            Extcodecopy
    49
        }
    50
    
                                                    
                                                
    51
        /// Forge execution contexts.
    52
        enum ForgeContext {
    53
            // Test group execution context (test, coverage or snapshot).
    54
            TestGroup,
    55
            // `forge test` execution context.
    56
            Test,
    57
            // `forge coverage` execution context.
    58
            Coverage,
    59
            // `forge snapshot` execution context.
    60
            Snapshot,
    61
            // Script group execution context (dry run, broadcast or resume).
    62
            ScriptGroup,
    63
            // `forge script` execution context.
    64
            ScriptDryRun,
    65
            // `forge script --broadcast` execution context.
    66
            ScriptBroadcast,
    67
            // `forge script --resume` execution context.
    68
            ScriptResume,
    69
            // Unknown `forge` execution context.
    70
            Unknown
    71
        }
    72
    
                                                    
                                                
    73
        /// The transaction type (`txType`) of the broadcast.
    74
        enum BroadcastTxType {
    75
            // Represents a CALL broadcast tx.
    76
            Call,
    77
            // Represents a CREATE broadcast tx.
    78
            Create,
    79
            // Represents a CREATE2 broadcast tx.
    80
            Create2
    81
        }
    82
    
                                                    
                                                
    83
        /// An Ethereum log. Returned by `getRecordedLogs`.
    84
        struct Log {
    85
            // The topics of the log, including the signature, if any.
    86
            bytes32[] topics;
    87
            // The raw data of the log.
    88
            bytes data;
    89
            // The address of the log's emitter.
    90
            address emitter;
    91
        }
    92
    
                                                    
                                                
    93
        /// An RPC URL and its alias. Returned by `rpcUrlStructs`.
    94
        struct Rpc {
    95
            // The alias of the RPC URL.
    96
            string key;
    97
            // The RPC URL.
    98
            string url;
    99
        }
    100
    
                                                    
                                                
    101
        /// An RPC log object. Returned by `eth_getLogs`.
    102
        struct EthGetLogs {
    103
            // The address of the log's emitter.
    104
            address emitter;
    105
            // The topics of the log, including the signature, if any.
    106
            bytes32[] topics;
    107
            // The raw data of the log.
    108
            bytes data;
    109
            // The block hash.
    110
            bytes32 blockHash;
    111
            // The block number.
    112
            uint64 blockNumber;
    113
            // The transaction hash.
    114
            bytes32 transactionHash;
    115
            // The transaction index in the block.
    116
            uint64 transactionIndex;
    117
            // The log index.
    118
            uint256 logIndex;
    119
            // Whether the log was removed.
    120
            bool removed;
    121
        }
    122
    
                                                    
                                                
    123
        /// A single entry in a directory listing. Returned by `readDir`.
    124
        struct DirEntry {
    125
            // The error message, if any.
    126
            string errorMessage;
    127
            // The path of the entry.
    128
            string path;
    129
            // The depth of the entry.
    130
            uint64 depth;
    131
            // Whether the entry is a directory.
    132
            bool isDir;
    133
            // Whether the entry is a symlink.
    134
            bool isSymlink;
    135
        }
    136
    
                                                    
                                                
    137
        /// Metadata information about a file.
    138
        /// This structure is returned from the `fsMetadata` function and represents known
    139
        /// metadata about a file such as its permissions, size, modification
    140
        /// times, etc.
    141
        struct FsMetadata {
    142
            // True if this metadata is for a directory.
    143
            bool isDir;
    144
            // True if this metadata is for a symlink.
    145
            bool isSymlink;
    146
            // The size of the file, in bytes, this metadata is for.
    147
            uint256 length;
    148
            // True if this metadata is for a readonly (unwritable) file.
    149
            bool readOnly;
    150
            // The last modification time listed in this metadata.
    151
            uint256 modified;
    152
            // The last access time of this metadata.
    153
            uint256 accessed;
    154
            // The creation time listed in this metadata.
    155
            uint256 created;
    156
        }
    157
    
                                                    
                                                
    158
        /// A wallet with a public and private key.
    159
        struct Wallet {
    160
            // The wallet's address.
    161
            address addr;
    162
            // The wallet's public key `X`.
    163
            uint256 publicKeyX;
    164
            // The wallet's public key `Y`.
    165
            uint256 publicKeyY;
    166
            // The wallet's private key.
    167
            uint256 privateKey;
    168
        }
    169
    
                                                    
                                                
    170
        /// The result of a `tryFfi` call.
    171
        struct FfiResult {
    172
            // The exit code of the call.
    173
            int32 exitCode;
    174
            // The optionally hex-decoded `stdout` data.
    175
            bytes stdout;
    176
            // The `stderr` data.
    177
            bytes stderr;
    178
        }
    179
    
                                                    
                                                
    180
        /// Information on the chain and fork.
    181
        struct ChainInfo {
    182
            // The fork identifier. Set to zero if no fork is active.
    183
            uint256 forkId;
    184
            // The chain ID of the current fork.
    185
            uint256 chainId;
    186
        }
    187
    
                                                    
                                                
    188
        /// Information about a blockchain.
    189
        struct Chain {
    190
            // The chain name.
    191
            string name;
    192
            // The chain's Chain ID.
    193
            uint256 chainId;
    194
            // The chain's alias. (i.e. what gets specified in `foundry.toml`).
    195
            string chainAlias;
    196
            // A default RPC endpoint for this chain.
    197
            string rpcUrl;
    198
        }
    199
    
                                                    
                                                
    200
        /// The result of a `stopAndReturnStateDiff` call.
    201
        struct AccountAccess {
    202
            // The chain and fork the access occurred.
    203
            ChainInfo chainInfo;
    204
            // The kind of account access that determines what the account is.
    205
            // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.
    206
            // If kind is Create, then the account is the newly created account.
    207
            // If kind is SelfDestruct, then the account is the selfdestruct recipient.
    208
            // If kind is a Resume, then account represents a account context that has resumed.
    209
            AccountAccessKind kind;
    210
            // The account that was accessed.
    211
            // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.
    212
            address account;
    213
            // What accessed the account.
    214
            address accessor;
    215
            // If the account was initialized or empty prior to the access.
    216
            // An account is considered initialized if it has code, a
    217
            // non-zero nonce, or a non-zero balance.
    218
            bool initialized;
    219
            // The previous balance of the accessed account.
    220
            uint256 oldBalance;
    221
            // The potential new balance of the accessed account.
    222
            // That is, all balance changes are recorded here, even if reverts occurred.
    223
            uint256 newBalance;
    224
            // Code of the account deployed by CREATE.
    225
            bytes deployedCode;
    226
            // Value passed along with the account access
    227
            uint256 value;
    228
            // Input data provided to the CREATE or CALL
    229
            bytes data;
    230
            // If this access reverted in either the current or parent context.
    231
            bool reverted;
    232
            // An ordered list of storage accesses made during an account access operation.
    233
            StorageAccess[] storageAccesses;
    234
            // Call depth traversed during the recording of state differences
    235
            uint64 depth;
    236
        }
    237
    
                                                    
                                                
    238
        /// The storage accessed during an `AccountAccess`.
    239
        struct StorageAccess {
    240
            // The account whose storage was accessed.
    241
            address account;
    242
            // The slot that was accessed.
    243
            bytes32 slot;
    244
            // If the access was a write.
    245
            bool isWrite;
    246
            // The previous value of the slot.
    247
            bytes32 previousValue;
    248
            // The new value of the slot.
    249
            bytes32 newValue;
    250
            // If the access was reverted.
    251
            bool reverted;
    252
        }
    253
    
                                                    
                                                
    254
        /// Gas used. Returned by `lastCallGas`.
    255
        struct Gas {
    256
            // The gas limit of the call.
    257
            uint64 gasLimit;
    258
            // The total gas used.
    259
            uint64 gasTotalUsed;
    260
            // DEPRECATED: The amount of gas used for memory expansion. Ref: <https://github.com/foundry-rs/foundry/pull/7934#pullrequestreview-2069236939>
    261
            uint64 gasMemoryUsed;
    262
            // The amount of gas refunded.
    263
            int64 gasRefunded;
    264
            // The amount of gas remaining.
    265
            uint64 gasRemaining;
    266
        }
    267
    
                                                    
                                                
    268
        /// The result of the `stopDebugTraceRecording` call
    269
        struct DebugStep {
    270
            // The stack before executing the step of the run.
    271
            // stack\[0\] represents the top of the stack.
    272
            // and only stack data relevant to the opcode execution is contained.
    273
            uint256[] stack;
    274
            // The memory input data before executing the step of the run.
    275
            // only input data relevant to the opcode execution is contained.
    276
            // e.g. for MLOAD, it will have memory\[offset:offset+32\] copied here.
    277
            // the offset value can be get by the stack data.
    278
            bytes memoryInput;
    279
            // The opcode that was accessed.
    280
            uint8 opcode;
    281
            // The call depth of the step.
    282
            uint64 depth;
    283
            // Whether the call end up with out of gas error.
    284
            bool isOutOfGas;
    285
            // The contract address where the opcode is running
    286
            address contractAddr;
    287
        }
    288
    
                                                    
                                                
    289
        /// Represents a transaction's broadcast details.
    290
        struct BroadcastTxSummary {
    291
            // The hash of the transaction that was broadcasted
    292
            bytes32 txHash;
    293
            // Represent the type of transaction among CALL, CREATE, CREATE2
    294
            BroadcastTxType txType;
    295
            // The address of the contract that was called or created.
    296
            // This is address of the contract that is created if the txType is CREATE or CREATE2.
    297
            address contractAddress;
    298
            // The block number the transaction landed in.
    299
            uint64 blockNumber;
    300
            // Status of the transaction, retrieved from the transaction receipt.
    301
            bool success;
    302
        }
    303
    
                                                    
                                                
    304
        /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.
    305
        struct SignedDelegation {
    306
            // The y-parity of the recovered secp256k1 signature (0 or 1).
    307
            uint8 v;
    308
            // First 32 bytes of the signature.
    309
            bytes32 r;
    310
            // Second 32 bytes of the signature.
    311
            bytes32 s;
    312
            // The current nonce of the authority account at signing time.
    313
            // Used to ensure signature can't be replayed after account nonce changes.
    314
            uint64 nonce;
    315
            // Address of the contract implementation that will be delegated to.
    316
            // Gets encoded into delegation code: 0xef0100 || implementation.
    317
            address implementation;
    318
        }
    319
    
                                                    
                                                
    320
        /// Represents a "potential" revert reason from a single subsequent call when using `vm.assumeNoReverts`.
    321
        /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced
    322
        /// as normal.
    323
        struct PotentialRevert {
    324
            // The allowed origin of the revert opcode; address(0) allows reverts from any address
    325
            address reverter;
    326
            // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data
    327
            bool partialMatch;
    328
            // The data to use to match encountered reverts
    329
            bytes revertData;
    330
        }
    331
    
                                                    
                                                
    332
        /// An EIP-2930 access list item.
    333
        struct AccessListItem {
    334
            // The address to be added in access list.
    335
            address target;
    336
            // The storage keys to be added in access list.
    337
            bytes32[] storageKeys;
    338
        }
    339
    
                                                    
                                                
    340
        // ======== Crypto ========
    341
    
                                                    
                                                
    342
        /// Derives a private key from the name, labels the account with that name, and returns the wallet.
    343
        function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);
    344
    
                                                    
                                                
    345
        /// Generates a wallet from the private key and returns the wallet.
    346
        function createWallet(uint256 privateKey) external returns (Wallet memory wallet);
    347
    
                                                    
                                                
    348
        /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.
    349
        function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);
    350
    
                                                    
                                                
    351
        /// Derive a private key from a provided mnenomic string (or mnenomic file path)
    352
        /// at the derivation path `m/44'/60'/0'/0/{index}`.
    353
        function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);
    354
    
                                                    
                                                
    355
        /// Derive a private key from a provided mnenomic string (or mnenomic file path)
    356
        /// at `{derivationPath}{index}`.
    357
        function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)
    358
            external
    359
            pure
    360
            returns (uint256 privateKey);
    361
    
                                                    
                                                
    362
        /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language
    363
        /// at the derivation path `m/44'/60'/0'/0/{index}`.
    364
        function deriveKey(string calldata mnemonic, uint32 index, string calldata language)
    365
            external
    366
            pure
    367
            returns (uint256 privateKey);
    368
    
                                                    
                                                
    369
        /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language
    370
        /// at `{derivationPath}{index}`.
    371
        function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)
    372
            external
    373
            pure
    374
            returns (uint256 privateKey);
    375
    
                                                    
                                                
    376
        /// Derives secp256r1 public key from the provided `privateKey`.
    377
        function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);
    378
    
                                                    
                                                
    379
        /// Adds a private key to the local forge wallet and returns the address.
    380
        function rememberKey(uint256 privateKey) external returns (address keyAddr);
    381
    
                                                    
                                                
    382
        /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.
    383
        /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.
    384
        function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)
    385
            external
    386
            returns (address[] memory keyAddrs);
    387
    
                                                    
                                                
    388
        /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.
    389
        /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.
    390
        function rememberKeys(
    391
            string calldata mnemonic,
    392
            string calldata derivationPath,
    393
            string calldata language,
    394
            uint32 count
    395
        ) external returns (address[] memory keyAddrs);
    396
    
                                                    
                                                
    397
        /// Signs data with a `Wallet`.
    398
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    399
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    400
        /// This format reduces the signature size from 65 to 64 bytes.
    401
        function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);
    402
    
                                                    
                                                
    403
        /// Signs `digest` with `privateKey` using the secp256k1 curve.
    404
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    405
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    406
        /// This format reduces the signature size from 65 to 64 bytes.
    407
        function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
    408
    
                                                    
                                                
    409
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    410
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    411
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    412
        /// This format reduces the signature size from 65 to 64 bytes.
    413
        /// If `--sender` is provided, the signer with provided address is used, otherwise,
    414
        /// if exactly one signer is provided to the script, that signer is used.
    415
        /// Raises error if signer passed through `--sender` does not match any unlocked signers or
    416
        /// if `--sender` is not provided and not exactly one signer is passed to the script.
    417
        function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
    418
    
                                                    
                                                
    419
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    420
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    421
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    422
        /// This format reduces the signature size from 65 to 64 bytes.
    423
        /// Raises error if none of the signers passed into the script have provided address.
    424
        function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
    425
    
                                                    
                                                
    426
        /// Signs `digest` with `privateKey` using the secp256r1 curve.
    427
        function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);
    428
    
                                                    
                                                
    429
        /// Signs data with a `Wallet`.
    430
        function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);
    431
    
                                                    
                                                
    432
        /// Signs `digest` with `privateKey` using the secp256k1 curve.
    433
        function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
    434
    
                                                    
                                                
    435
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    436
        /// If `--sender` is provided, the signer with provided address is used, otherwise,
    437
        /// if exactly one signer is provided to the script, that signer is used.
    438
        /// Raises error if signer passed through `--sender` does not match any unlocked signers or
    439
        /// if `--sender` is not provided and not exactly one signer is passed to the script.
    440
        function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
    441
    
                                                    
                                                
    442
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    443
        /// Raises error if none of the signers passed into the script have provided address.
    444
        function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
    445
    
                                                    
                                                
    446
        // ======== Environment ========
    447
    
                                                    
                                                
    448
        /// Gets the environment variable `name` and parses it as `address`.
    449
        /// Reverts if the variable was not found or could not be parsed.
    450
        function envAddress(string calldata name) external view returns (address value);
    451
    
                                                    
                                                
    452
        /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.
    453
        /// Reverts if the variable was not found or could not be parsed.
    454
        function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);
    455
    
                                                    
                                                
    456
        /// Gets the environment variable `name` and parses it as `bool`.
    457
        /// Reverts if the variable was not found or could not be parsed.
    458
        function envBool(string calldata name) external view returns (bool value);
    459
    
                                                    
                                                
    460
        /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.
    461
        /// Reverts if the variable was not found or could not be parsed.
    462
        function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);
    463
    
                                                    
                                                
    464
        /// Gets the environment variable `name` and parses it as `bytes32`.
    465
        /// Reverts if the variable was not found or could not be parsed.
    466
        function envBytes32(string calldata name) external view returns (bytes32 value);
    467
    
                                                    
                                                
    468
        /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.
    469
        /// Reverts if the variable was not found or could not be parsed.
    470
        function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);
    471
    
                                                    
                                                
    472
        /// Gets the environment variable `name` and parses it as `bytes`.
    473
        /// Reverts if the variable was not found or could not be parsed.
    474
        function envBytes(string calldata name) external view returns (bytes memory value);
    475
    
                                                    
                                                
    476
        /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.
    477
        /// Reverts if the variable was not found or could not be parsed.
    478
        function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);
    479
    
                                                    
                                                
    480
        /// Gets the environment variable `name` and returns true if it exists, else returns false.
    481
        function envExists(string calldata name) external view returns (bool result);
    482
    
                                                    
                                                
    483
        /// Gets the environment variable `name` and parses it as `int256`.
    484
        /// Reverts if the variable was not found or could not be parsed.
    485
        function envInt(string calldata name) external view returns (int256 value);
    486
    
                                                    
                                                
    487
        /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.
    488
        /// Reverts if the variable was not found or could not be parsed.
    489
        function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);
    490
    
                                                    
                                                
    491
        /// Gets the environment variable `name` and parses it as `bool`.
    492
        /// Reverts if the variable could not be parsed.
    493
        /// Returns `defaultValue` if the variable was not found.
    494
        function envOr(string calldata name, bool defaultValue) external view returns (bool value);
    495
    
                                                    
                                                
    496
        /// Gets the environment variable `name` and parses it as `uint256`.
    497
        /// Reverts if the variable could not be parsed.
    498
        /// Returns `defaultValue` if the variable was not found.
    499
        function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);
    500
    
                                                    
                                                
    501
        /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.
    502
        /// Reverts if the variable could not be parsed.
    503
        /// Returns `defaultValue` if the variable was not found.
    504
        function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)
    505
            external
    506
            view
    507
            returns (address[] memory value);
    508
    
                                                    
                                                
    509
        /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.
    510
        /// Reverts if the variable could not be parsed.
    511
        /// Returns `defaultValue` if the variable was not found.
    512
        function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)
    513
            external
    514
            view
    515
            returns (bytes32[] memory value);
    516
    
                                                    
                                                
    517
        /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.
    518
        /// Reverts if the variable could not be parsed.
    519
        /// Returns `defaultValue` if the variable was not found.
    520
        function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)
    521
            external
    522
            view
    523
            returns (string[] memory value);
    524
    
                                                    
                                                
    525
        /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.
    526
        /// Reverts if the variable could not be parsed.
    527
        /// Returns `defaultValue` if the variable was not found.
    528
        function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)
    529
            external
    530
            view
    531
            returns (bytes[] memory value);
    532
    
                                                    
                                                
    533
        /// Gets the environment variable `name` and parses it as `int256`.
    534
        /// Reverts if the variable could not be parsed.
    535
        /// Returns `defaultValue` if the variable was not found.
    536
        function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);
    537
    
                                                    
                                                
    538
        /// Gets the environment variable `name` and parses it as `address`.
    539
        /// Reverts if the variable could not be parsed.
    540
        /// Returns `defaultValue` if the variable was not found.
    541
        function envOr(string calldata name, address defaultValue) external view returns (address value);
    542
    
                                                    
                                                
    543
        /// Gets the environment variable `name` and parses it as `bytes32`.
    544
        /// Reverts if the variable could not be parsed.
    545
        /// Returns `defaultValue` if the variable was not found.
    546
        function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);
    547
    
                                                    
                                                
    548
        /// Gets the environment variable `name` and parses it as `string`.
    549
        /// Reverts if the variable could not be parsed.
    550
        /// Returns `defaultValue` if the variable was not found.
    551
        function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);
    552
    
                                                    
                                                
    553
        /// Gets the environment variable `name` and parses it as `bytes`.
    554
        /// Reverts if the variable could not be parsed.
    555
        /// Returns `defaultValue` if the variable was not found.
    556
        function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);
    557
    
                                                    
                                                
    558
        /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.
    559
        /// Reverts if the variable could not be parsed.
    560
        /// Returns `defaultValue` if the variable was not found.
    561
        function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)
    562
            external
    563
            view
    564
            returns (bool[] memory value);
    565
    
                                                    
                                                
    566
        /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.
    567
        /// Reverts if the variable could not be parsed.
    568
        /// Returns `defaultValue` if the variable was not found.
    569
        function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)
    570
            external
    571
            view
    572
            returns (uint256[] memory value);
    573
    
                                                    
                                                
    574
        /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.
    575
        /// Reverts if the variable could not be parsed.
    576
        /// Returns `defaultValue` if the variable was not found.
    577
        function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)
    578
            external
    579
            view
    580
            returns (int256[] memory value);
    581
    
                                                    
                                                
    582
        /// Gets the environment variable `name` and parses it as `string`.
    583
        /// Reverts if the variable was not found or could not be parsed.
    584
        function envString(string calldata name) external view returns (string memory value);
    585
    
                                                    
                                                
    586
        /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.
    587
        /// Reverts if the variable was not found or could not be parsed.
    588
        function envString(string calldata name, string calldata delim) external view returns (string[] memory value);
    589
    
                                                    
                                                
    590
        /// Gets the environment variable `name` and parses it as `uint256`.
    591
        /// Reverts if the variable was not found or could not be parsed.
    592
        function envUint(string calldata name) external view returns (uint256 value);
    593
    
                                                    
                                                
    594
        /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.
    595
        /// Reverts if the variable was not found or could not be parsed.
    596
        function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);
    597
    
                                                    
                                                
    598
        /// Returns true if `forge` command was executed in given context.
    599
        function isContext(ForgeContext context) external view returns (bool result);
    600
    
                                                    
                                                
    601
        /// Sets environment variables.
    602
        function setEnv(string calldata name, string calldata value) external;
    603
    
                                                    
                                                
    604
        // ======== EVM ========
    605
    
                                                    
                                                
    606
        /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.
    607
        function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);
    608
    
                                                    
                                                
    609
        /// Gets the address for a given private key.
    610
        function addr(uint256 privateKey) external pure returns (address keyAddr);
    611
    
                                                    
                                                
    612
        /// Gets all the logs according to specified filter.
    613
        function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)
    614
            external
    615
            returns (EthGetLogs[] memory logs);
    616
    
                                                    
                                                
    617
        /// Gets the current `block.blobbasefee`.
    618
        /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,
    619
        /// and as a result will get optimized out by the compiler.
    620
        /// See https://github.com/foundry-rs/foundry/issues/6180
    621
        function getBlobBaseFee() external view returns (uint256 blobBaseFee);
    622
    
                                                    
                                                
    623
        /// Gets the current `block.number`.
    624
        /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,
    625
        /// and as a result will get optimized out by the compiler.
    626
        /// See https://github.com/foundry-rs/foundry/issues/6180
    627
        function getBlockNumber() external view returns (uint256 height);
    628
    
                                                    
                                                
    629
        /// Gets the current `block.timestamp`.
    630
        /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,
    631
        /// and as a result will get optimized out by the compiler.
    632
        /// See https://github.com/foundry-rs/foundry/issues/6180
    633
        function getBlockTimestamp() external view returns (uint256 timestamp);
    634
    
                                                    
                                                
    635
        /// Gets the map key and parent of a mapping at a given slot, for a given address.
    636
        function getMappingKeyAndParentOf(address target, bytes32 elementSlot)
    637
            external
    638
            returns (bool found, bytes32 key, bytes32 parent);
    639
    
                                                    
                                                
    640
        /// Gets the number of elements in the mapping at the given slot, for a given address.
    641
        function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);
    642
    
                                                    
                                                
    643
        /// Gets the elements at index idx of the mapping at the given slot, for a given address. The
    644
        /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).
    645
        function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);
    646
    
                                                    
                                                
    647
        /// Gets the nonce of an account.
    648
        function getNonce(address account) external view returns (uint64 nonce);
    649
    
                                                    
                                                
    650
        /// Get the nonce of a `Wallet`.
    651
        function getNonce(Wallet calldata wallet) external returns (uint64 nonce);
    652
    
                                                    
                                                
    653
        /// Gets the RLP encoded block header for a given block number.
    654
        /// Returns the block header in the same format as `cast block <block_number> --raw`.
    655
        function getRawBlockHeader(uint256 blockNumber) external view returns (bytes memory rlpHeader);
    656
    
                                                    
                                                
    657
        /// Gets all the recorded logs.
    658
        function getRecordedLogs() external returns (Log[] memory logs);
    659
    
                                                    
                                                
    660
        /// Returns state diffs from current `vm.startStateDiffRecording` session.
    661
        function getStateDiff() external view returns (string memory diff);
    662
    
                                                    
                                                
    663
        /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.
    664
        function getStateDiffJson() external view returns (string memory diff);
    665
    
                                                    
                                                
    666
        /// Gets the gas used in the last call from the callee perspective.
    667
        function lastCallGas() external view returns (Gas memory gas);
    668
    
                                                    
                                                
    669
        /// Loads a storage slot from an address.
    670
        function load(address target, bytes32 slot) external view returns (bytes32 data);
    671
    
                                                    
                                                
    672
        /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.
    673
        function pauseGasMetering() external;
    674
    
                                                    
                                                
    675
        /// Records all storage reads and writes. Use `accesses` to get the recorded data.
    676
        /// Subsequent calls to `record` will clear the previous data.
    677
        function record() external;
    678
    
                                                    
                                                
    679
        /// Record all the transaction logs.
    680
        function recordLogs() external;
    681
    
                                                    
                                                
    682
        /// Reset gas metering (i.e. gas usage is set to gas limit).
    683
        function resetGasMetering() external;
    684
    
                                                    
                                                
    685
        /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.
    686
        function resumeGasMetering() external;
    687
    
                                                    
                                                
    688
        /// Performs an Ethereum JSON-RPC request to the current fork URL.
    689
        function rpc(string calldata method, string calldata params) external returns (bytes memory data);
    690
    
                                                    
                                                
    691
        /// Performs an Ethereum JSON-RPC request to the given endpoint.
    692
        function rpc(string calldata urlOrAlias, string calldata method, string calldata params)
    693
            external
    694
            returns (bytes memory data);
    695
    
                                                    
                                                
    696
        /// Records the debug trace during the run.
    697
        function startDebugTraceRecording() external;
    698
    
                                                    
                                                
    699
        /// Starts recording all map SSTOREs for later retrieval.
    700
        function startMappingRecording() external;
    701
    
                                                    
                                                
    702
        /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,
    703
        /// along with the context of the calls
    704
        function startStateDiffRecording() external;
    705
    
                                                    
                                                
    706
        /// Stop debug trace recording and returns the recorded debug trace.
    707
        function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);
    708
    
                                                    
                                                
    709
        /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.
    710
        function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);
    711
    
                                                    
                                                
    712
        /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.
    713
        function stopMappingRecording() external;
    714
    
                                                    
                                                
    715
        /// Stops recording storage reads and writes.
    716
        function stopRecord() external;
    717
    
                                                    
                                                
    718
        // ======== Filesystem ========
    719
    
                                                    
                                                
    720
        /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.
    721
        /// `path` is relative to the project root.
    722
        function closeFile(string calldata path) external;
    723
    
                                                    
                                                
    724
        /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.
    725
        /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.
    726
        /// Both `from` and `to` are relative to the project root.
    727
        function copyFile(string calldata from, string calldata to) external returns (uint64 copied);
    728
    
                                                    
                                                
    729
        /// Creates a new, empty directory at the provided path.
    730
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    731
        /// - User lacks permissions to modify `path`.
    732
        /// - A parent of the given path doesn't exist and `recursive` is false.
    733
        /// - `path` already exists and `recursive` is false.
    734
        /// `path` is relative to the project root.
    735
        function createDir(string calldata path, bool recursive) external;
    736
    
                                                    
                                                
    737
        /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
    738
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    739
        function deployCode(string calldata artifactPath) external returns (address deployedAddress);
    740
    
                                                    
                                                
    741
        /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
    742
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    743
        /// Additionally accepts abi-encoded constructor arguments.
    744
        function deployCode(string calldata artifactPath, bytes calldata constructorArgs)
    745
            external
    746
            returns (address deployedAddress);
    747
    
                                                    
                                                
    748
        /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
    749
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    750
        /// Additionally accepts `msg.value`.
    751
        function deployCode(string calldata artifactPath, uint256 value) external returns (address deployedAddress);
    752
    
                                                    
                                                
    753
        /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
    754
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    755
        /// Additionally accepts abi-encoded constructor arguments and `msg.value`.
    756
        function deployCode(string calldata artifactPath, bytes calldata constructorArgs, uint256 value)
    757
            external
    758
            returns (address deployedAddress);
    759
    
                                                    
                                                
    760
        /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the
    761
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    762
        function deployCode(string calldata artifactPath, bytes32 salt) external returns (address deployedAddress);
    763
    
                                                    
                                                
    764
        /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the
    765
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    766
        /// Additionally accepts abi-encoded constructor arguments.
    767
        function deployCode(string calldata artifactPath, bytes calldata constructorArgs, bytes32 salt)
    768
            external
    769
            returns (address deployedAddress);
    770
    
                                                    
                                                
    771
        /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the
    772
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    773
        /// Additionally accepts `msg.value`.
    774
        function deployCode(string calldata artifactPath, uint256 value, bytes32 salt)
    775
            external
    776
            returns (address deployedAddress);
    777
    
                                                    
                                                
    778
        /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the
    779
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    780
        /// Additionally accepts abi-encoded constructor arguments and `msg.value`.
    781
        function deployCode(string calldata artifactPath, bytes calldata constructorArgs, uint256 value, bytes32 salt)
    782
            external
    783
            returns (address deployedAddress);
    784
    
                                                    
                                                
    785
        /// Returns true if the given path points to an existing entity, else returns false.
    786
        function exists(string calldata path) external view returns (bool result);
    787
    
                                                    
                                                
    788
        /// Performs a foreign function call via the terminal.
    789
        function ffi(string[] calldata commandInput) external returns (bytes memory result);
    790
    
                                                    
                                                
    791
        /// Given a path, query the file system to get information about a file, directory, etc.
    792
        function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);
    793
    
                                                    
                                                
    794
        /// Gets the artifact path from code (aka. creation code).
    795
        function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);
    796
    
                                                    
                                                
    797
        /// Gets the artifact path from deployed code (aka. runtime code).
    798
        function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);
    799
    
                                                    
                                                
    800
        /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.
    801
        /// For example:
    802
        /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.
    803
        /// The most recent call can be fetched by passing `txType` as `CALL`.
    804
        function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)
    805
            external
    806
            view
    807
            returns (BroadcastTxSummary memory);
    808
    
                                                    
                                                
    809
        /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.
    810
        /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.
    811
        function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)
    812
            external
    813
            view
    814
            returns (BroadcastTxSummary[] memory);
    815
    
                                                    
                                                
    816
        /// Returns all broadcasts for the given contract on `chainId`.
    817
        /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.
    818
        function getBroadcasts(string calldata contractName, uint64 chainId)
    819
            external
    820
            view
    821
            returns (BroadcastTxSummary[] memory);
    822
    
                                                    
                                                
    823
        /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the
    824
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    825
        function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);
    826
    
                                                    
                                                
    827
        /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the
    828
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    829
        function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);
    830
    
                                                    
                                                
    831
        /// Returns the most recent deployment for the current `chainId`.
    832
        function getDeployment(string calldata contractName) external view returns (address deployedAddress);
    833
    
                                                    
                                                
    834
        /// Returns the most recent deployment for the given contract on `chainId`
    835
        function getDeployment(string calldata contractName, uint64 chainId)
    836
            external
    837
            view
    838
            returns (address deployedAddress);
    839
    
                                                    
                                                
    840
        /// Returns all deployments for the given contract on `chainId`
    841
        /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.
    842
        /// The most recent deployment is the first element, and the oldest is the last.
    843
        function getDeployments(string calldata contractName, uint64 chainId)
    844
            external
    845
            view
    846
            returns (address[] memory deployedAddresses);
    847
    
                                                    
                                                
    848
        /// Returns true if the path exists on disk and is pointing at a directory, else returns false.
    849
        function isDir(string calldata path) external view returns (bool result);
    850
    
                                                    
                                                
    851
        /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.
    852
        function isFile(string calldata path) external view returns (bool result);
    853
    
                                                    
                                                
    854
        /// Get the path of the current project root.
    855
        function projectRoot() external view returns (string memory path);
    856
    
                                                    
                                                
    857
        /// Prompts the user for a string value in the terminal.
    858
        function prompt(string calldata promptText) external returns (string memory input);
    859
    
                                                    
                                                
    860
        /// Prompts the user for an address in the terminal.
    861
        function promptAddress(string calldata promptText) external returns (address);
    862
    
                                                    
                                                
    863
        /// Prompts the user for a hidden string value in the terminal.
    864
        function promptSecret(string calldata promptText) external returns (string memory input);
    865
    
                                                    
                                                
    866
        /// Prompts the user for hidden uint256 in the terminal (usually pk).
    867
        function promptSecretUint(string calldata promptText) external returns (uint256);
    868
    
                                                    
                                                
    869
        /// Prompts the user for uint256 in the terminal.
    870
        function promptUint(string calldata promptText) external returns (uint256);
    871
    
                                                    
                                                
    872
        /// Reads the directory at the given path recursively, up to `maxDepth`.
    873
        /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.
    874
        /// Follows symbolic links if `followLinks` is true.
    875
        function readDir(string calldata path) external view returns (DirEntry[] memory entries);
    876
    
                                                    
                                                
    877
        /// See `readDir(string)`.
    878
        function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);
    879
    
                                                    
                                                
    880
        /// See `readDir(string)`.
    881
        function readDir(string calldata path, uint64 maxDepth, bool followLinks)
    882
            external
    883
            view
    884
            returns (DirEntry[] memory entries);
    885
    
                                                    
                                                
    886
        /// Reads the entire content of file to string. `path` is relative to the project root.
    887
        function readFile(string calldata path) external view returns (string memory data);
    888
    
                                                    
                                                
    889
        /// Reads the entire content of file as binary. `path` is relative to the project root.
    890
        function readFileBinary(string calldata path) external view returns (bytes memory data);
    891
    
                                                    
                                                
    892
        /// Reads next line of file to string.
    893
        function readLine(string calldata path) external view returns (string memory line);
    894
    
                                                    
                                                
    895
        /// Reads a symbolic link, returning the path that the link points to.
    896
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    897
        /// - `path` is not a symbolic link.
    898
        /// - `path` does not exist.
    899
        function readLink(string calldata linkPath) external view returns (string memory targetPath);
    900
    
                                                    
                                                
    901
        /// Removes a directory at the provided path.
    902
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    903
        /// - `path` doesn't exist.
    904
        /// - `path` isn't a directory.
    905
        /// - User lacks permissions to modify `path`.
    906
        /// - The directory is not empty and `recursive` is false.
    907
        /// `path` is relative to the project root.
    908
        function removeDir(string calldata path, bool recursive) external;
    909
    
                                                    
                                                
    910
        /// Removes a file from the filesystem.
    911
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    912
        /// - `path` points to a directory.
    913
        /// - The file doesn't exist.
    914
        /// - The user lacks permissions to remove the file.
    915
        /// `path` is relative to the project root.
    916
        function removeFile(string calldata path) external;
    917
    
                                                    
                                                
    918
        /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.
    919
        function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);
    920
    
                                                    
                                                
    921
        /// Returns the time since unix epoch in milliseconds.
    922
        function unixTime() external view returns (uint256 milliseconds);
    923
    
                                                    
                                                
    924
        /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.
    925
        /// `path` is relative to the project root.
    926
        function writeFile(string calldata path, string calldata data) external;
    927
    
                                                    
                                                
    928
        /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.
    929
        /// `path` is relative to the project root.
    930
        function writeFileBinary(string calldata path, bytes calldata data) external;
    931
    
                                                    
                                                
    932
        /// Writes line to file, creating a file if it does not exist.
    933
        /// `path` is relative to the project root.
    934
        function writeLine(string calldata path, string calldata data) external;
    935
    
                                                    
                                                
    936
        // ======== JSON ========
    937
    
                                                    
                                                
    938
        /// Checks if `key` exists in a JSON object.
    939
        function keyExistsJson(string calldata json, string calldata key) external view returns (bool);
    940
    
                                                    
                                                
    941
        /// Parses a string of JSON data at `key` and coerces it to `address`.
    942
        function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);
    943
    
                                                    
                                                
    944
        /// Parses a string of JSON data at `key` and coerces it to `address[]`.
    945
        function parseJsonAddressArray(string calldata json, string calldata key)
    946
            external
    947
            pure
    948
            returns (address[] memory);
    949
    
                                                    
                                                
    950
        /// Parses a string of JSON data at `key` and coerces it to `bool`.
    951
        function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);
    952
    
                                                    
                                                
    953
        /// Parses a string of JSON data at `key` and coerces it to `bool[]`.
    954
        function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);
    955
    
                                                    
                                                
    956
        /// Parses a string of JSON data at `key` and coerces it to `bytes`.
    957
        function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);
    958
    
                                                    
                                                
    959
        /// Parses a string of JSON data at `key` and coerces it to `bytes32`.
    960
        function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);
    961
    
                                                    
                                                
    962
        /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.
    963
        function parseJsonBytes32Array(string calldata json, string calldata key)
    964
            external
    965
            pure
    966
            returns (bytes32[] memory);
    967
    
                                                    
                                                
    968
        /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.
    969
        function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);
    970
    
                                                    
                                                
    971
        /// Parses a string of JSON data at `key` and coerces it to `int256`.
    972
        function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);
    973
    
                                                    
                                                
    974
        /// Parses a string of JSON data at `key` and coerces it to `int256[]`.
    975
        function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);
    976
    
                                                    
                                                
    977
        /// Returns an array of all the keys in a JSON object.
    978
        function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);
    979
    
                                                    
                                                
    980
        /// Parses a string of JSON data at `key` and coerces it to `string`.
    981
        function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);
    982
    
                                                    
                                                
    983
        /// Parses a string of JSON data at `key` and coerces it to `string[]`.
    984
        function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);
    985
    
                                                    
                                                
    986
        /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.
    987
        function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)
    988
            external
    989
            pure
    990
            returns (bytes memory);
    991
    
                                                    
                                                
    992
        /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.
    993
        function parseJsonType(string calldata json, string calldata typeDescription)
    994
            external
    995
            pure
    996
            returns (bytes memory);
    997
    
                                                    
                                                
    998
        /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.
    999
        function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)
    1000
            external
    1001
            pure
    1002
            returns (bytes memory);
    1003
    
                                                    
                                                
    1004
        /// Parses a string of JSON data at `key` and coerces it to `uint256`.
    1005
        function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);
    1006
    
                                                    
                                                
    1007
        /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.
    1008
        function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);
    1009
    
                                                    
                                                
    1010
        /// ABI-encodes a JSON object.
    1011
        function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);
    1012
    
                                                    
                                                
    1013
        /// ABI-encodes a JSON object at `key`.
    1014
        function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);
    1015
    
                                                    
                                                
    1016
        /// See `serializeJson`.
    1017
        function serializeAddress(string calldata objectKey, string calldata valueKey, address value)
    1018
            external
    1019
            returns (string memory json);
    1020
    
                                                    
                                                
    1021
        /// See `serializeJson`.
    1022
        function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)
    1023
            external
    1024
            returns (string memory json);
    1025
    
                                                    
                                                
    1026
        /// See `serializeJson`.
    1027
        function serializeBool(string calldata objectKey, string calldata valueKey, bool value)
    1028
            external
    1029
            returns (string memory json);
    1030
    
                                                    
                                                
    1031
        /// See `serializeJson`.
    1032
        function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)
    1033
            external
    1034
            returns (string memory json);
    1035
    
                                                    
                                                
    1036
        /// See `serializeJson`.
    1037
        function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)
    1038
            external
    1039
            returns (string memory json);
    1040
    
                                                    
                                                
    1041
        /// See `serializeJson`.
    1042
        function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)
    1043
            external
    1044
            returns (string memory json);
    1045
    
                                                    
                                                
    1046
        /// See `serializeJson`.
    1047
        function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)
    1048
            external
    1049
            returns (string memory json);
    1050
    
                                                    
                                                
    1051
        /// See `serializeJson`.
    1052
        function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)
    1053
            external
    1054
            returns (string memory json);
    1055
    
                                                    
                                                
    1056
        /// See `serializeJson`.
    1057
        function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)
    1058
            external
    1059
            returns (string memory json);
    1060
    
                                                    
                                                
    1061
        /// See `serializeJson`.
    1062
        function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)
    1063
            external
    1064
            returns (string memory json);
    1065
    
                                                    
                                                
    1066
        /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.
    1067
        /// Returns the stringified version of the specific JSON file up to that moment.
    1068
        function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);
    1069
    
                                                    
                                                
    1070
        /// See `serializeJson`.
    1071
        function serializeJsonType(string calldata typeDescription, bytes calldata value)
    1072
            external
    1073
            pure
    1074
            returns (string memory json);
    1075
    
                                                    
                                                
    1076
        /// See `serializeJson`.
    1077
        function serializeJsonType(
    1078
            string calldata objectKey,
    1079
            string calldata valueKey,
    1080
            string calldata typeDescription,
    1081
            bytes calldata value
    1082
        ) external returns (string memory json);
    1083
    
                                                    
                                                
    1084
        /// See `serializeJson`.
    1085
        function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)
    1086
            external
    1087
            returns (string memory json);
    1088
    
                                                    
                                                
    1089
        /// See `serializeJson`.
    1090
        function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)
    1091
            external
    1092
            returns (string memory json);
    1093
    
                                                    
                                                
    1094
        /// See `serializeJson`.
    1095
        function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)
    1096
            external
    1097
            returns (string memory json);
    1098
    
                                                    
                                                
    1099
        /// See `serializeJson`.
    1100
        function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)
    1101
            external
    1102
            returns (string memory json);
    1103
    
                                                    
                                                
    1104
        /// See `serializeJson`.
    1105
        function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)
    1106
            external
    1107
            returns (string memory json);
    1108
    
                                                    
                                                
    1109
        /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.
    1110
        function writeJson(string calldata json, string calldata path) external;
    1111
    
                                                    
                                                
    1112
        /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = <value_key.>
    1113
        /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.
    1114
        function writeJson(string calldata json, string calldata path, string calldata valueKey) external;
    1115
    
                                                    
                                                
    1116
        /// Checks if `key` exists in a JSON object
    1117
        /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.
    1118
        function keyExists(string calldata json, string calldata key) external view returns (bool);
    1119
    
                                                    
                                                
    1120
        // ======== Scripting ========
    1121
    
                                                    
                                                
    1122
        /// Attach an EIP-4844 blob to the next call
    1123
        function attachBlob(bytes calldata blob) external;
    1124
    
                                                    
                                                
    1125
        /// Designate the next call as an EIP-7702 transaction
    1126
        function attachDelegation(SignedDelegation calldata signedDelegation) external;
    1127
    
                                                    
                                                
    1128
        /// Designate the next call as an EIP-7702 transaction, with optional cross-chain validity.
    1129
        function attachDelegation(SignedDelegation calldata signedDelegation, bool crossChain) external;
    1130
    
                                                    
                                                
    1131
        /// Takes a signed transaction and broadcasts it to the network.
    1132
        function broadcastRawTransaction(bytes calldata data) external;
    1133
    
                                                    
                                                
    1134
        /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.
    1135
        /// Broadcasting address is determined by checking the following in order:
    1136
        /// 1. If `--sender` argument was provided, that address is used.
    1137
        /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.
    1138
        /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.
    1139
        function broadcast() external;
    1140
    
                                                    
                                                
    1141
        /// Has the next call (at this call depth only) create a transaction with the address provided
    1142
        /// as the sender that can later be signed and sent onchain.
    1143
        function broadcast(address signer) external;
    1144
    
                                                    
                                                
    1145
        /// Has the next call (at this call depth only) create a transaction with the private key
    1146
        /// provided as the sender that can later be signed and sent onchain.
    1147
        function broadcast(uint256 privateKey) external;
    1148
    
                                                    
                                                
    1149
        /// Returns addresses of available unlocked wallets in the script environment.
    1150
        function getWallets() external returns (address[] memory wallets);
    1151
    
                                                    
                                                
    1152
        /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction
    1153
        function signAndAttachDelegation(address implementation, uint256 privateKey)
    1154
            external
    1155
            returns (SignedDelegation memory signedDelegation);
    1156
    
                                                    
                                                
    1157
        /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction for specific nonce
    1158
        function signAndAttachDelegation(address implementation, uint256 privateKey, uint64 nonce)
    1159
            external
    1160
            returns (SignedDelegation memory signedDelegation);
    1161
    
                                                    
                                                
    1162
        /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction, with optional cross-chain validity.
    1163
        function signAndAttachDelegation(address implementation, uint256 privateKey, bool crossChain)
    1164
            external
    1165
            returns (SignedDelegation memory signedDelegation);
    1166
    
                                                    
                                                
    1167
        /// Sign an EIP-7702 authorization for delegation
    1168
        function signDelegation(address implementation, uint256 privateKey)
    1169
            external
    1170
            returns (SignedDelegation memory signedDelegation);
    1171
    
                                                    
                                                
    1172
        /// Sign an EIP-7702 authorization for delegation for specific nonce
    1173
        function signDelegation(address implementation, uint256 privateKey, uint64 nonce)
    1174
            external
    1175
            returns (SignedDelegation memory signedDelegation);
    1176
    
                                                    
                                                
    1177
        /// Sign an EIP-7702 authorization for delegation, with optional cross-chain validity.
    1178
        function signDelegation(address implementation, uint256 privateKey, bool crossChain)
    1179
            external
    1180
            returns (SignedDelegation memory signedDelegation);
    1181
    
                                                    
                                                
    1182
        /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.
    1183
        /// Broadcasting address is determined by checking the following in order:
    1184
        /// 1. If `--sender` argument was provided, that address is used.
    1185
        /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.
    1186
        /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.
    1187
        function startBroadcast() external;
    1188
    
                                                    
                                                
    1189
        /// Has all subsequent calls (at this call depth only) create transactions with the address
    1190
        /// provided that can later be signed and sent onchain.
    1191
        function startBroadcast(address signer) external;
    1192
    
                                                    
                                                
    1193
        /// Has all subsequent calls (at this call depth only) create transactions with the private key
    1194
        /// provided that can later be signed and sent onchain.
    1195
        function startBroadcast(uint256 privateKey) external;
    1196
    
                                                    
                                                
    1197
        /// Stops collecting onchain transactions.
    1198
        function stopBroadcast() external;
    1199
    
                                                    
                                                
    1200
        // ======== String ========
    1201
    
                                                    
                                                
    1202
        /// Returns true if `search` is found in `subject`, false otherwise.
    1203
        function contains(string calldata subject, string calldata search) external returns (bool result);
    1204
    
                                                    
                                                
    1205
        /// Returns the index of the first occurrence of a `key` in an `input` string.
    1206
        /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.
    1207
        /// Returns 0 in case of an empty `key`.
    1208
        function indexOf(string calldata input, string calldata key) external pure returns (uint256);
    1209
    
                                                    
                                                
    1210
        /// Parses the given `string` into an `address`.
    1211
        function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);
    1212
    
                                                    
                                                
    1213
        /// Parses the given `string` into a `bool`.
    1214
        function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);
    1215
    
                                                    
                                                
    1216
        /// Parses the given `string` into `bytes`.
    1217
        function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);
    1218
    
                                                    
                                                
    1219
        /// Parses the given `string` into a `bytes32`.
    1220
        function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);
    1221
    
                                                    
                                                
    1222
        /// Parses the given `string` into a `int256`.
    1223
        function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);
    1224
    
                                                    
                                                
    1225
        /// Parses the given `string` into a `uint256`.
    1226
        function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);
    1227
    
                                                    
                                                
    1228
        /// Replaces occurrences of `from` in the given `string` with `to`.
    1229
        function replace(string calldata input, string calldata from, string calldata to)
    1230
            external
    1231
            pure
    1232
            returns (string memory output);
    1233
    
                                                    
                                                
    1234
        /// Splits the given `string` into an array of strings divided by the `delimiter`.
    1235
        function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);
    1236
    
                                                    
                                                
    1237
        /// Converts the given `string` value to Lowercase.
    1238
        function toLowercase(string calldata input) external pure returns (string memory output);
    1239
    
                                                    
                                                
    1240
        /// Converts the given value to a `string`.
    1241
        function toString(address value) external pure returns (string memory stringifiedValue);
    1242
    
                                                    
                                                
    1243
        /// Converts the given value to a `string`.
    1244
        function toString(bytes calldata value) external pure returns (string memory stringifiedValue);
    1245
    
                                                    
                                                
    1246
        /// Converts the given value to a `string`.
    1247
        function toString(bytes32 value) external pure returns (string memory stringifiedValue);
    1248
    
                                                    
                                                
    1249
        /// Converts the given value to a `string`.
    1250
        function toString(bool value) external pure returns (string memory stringifiedValue);
    1251
    
                                                    
                                                
    1252
        /// Converts the given value to a `string`.
    1253
        function toString(uint256 value) external pure returns (string memory stringifiedValue);
    1254
    
                                                    
                                                
    1255
        /// Converts the given value to a `string`.
    1256
        function toString(int256 value) external pure returns (string memory stringifiedValue);
    1257
    
                                                    
                                                
    1258
        /// Converts the given `string` value to Uppercase.
    1259
        function toUppercase(string calldata input) external pure returns (string memory output);
    1260
    
                                                    
                                                
    1261
        /// Trims leading and trailing whitespace from the given `string` value.
    1262
        function trim(string calldata input) external pure returns (string memory output);
    1263
    
                                                    
                                                
    1264
        // ======== Testing ========
    1265
    
                                                    
                                                
    1266
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1267
        /// Formats values with decimals in failure message.
    1268
        function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;
    1269
    
                                                    
                                                
    1270
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1271
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1272
        function assertApproxEqAbsDecimal(
    1273
            uint256 left,
    1274
            uint256 right,
    1275
            uint256 maxDelta,
    1276
            uint256 decimals,
    1277
            string calldata error
    1278
        ) external pure;
    1279
    
                                                    
                                                
    1280
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1281
        /// Formats values with decimals in failure message.
    1282
        function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;
    1283
    
                                                    
                                                
    1284
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1285
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1286
        function assertApproxEqAbsDecimal(
    1287
            int256 left,
    1288
            int256 right,
    1289
            uint256 maxDelta,
    1290
            uint256 decimals,
    1291
            string calldata error
    1292
        ) external pure;
    1293
    
                                                    
                                                
    1294
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1295
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;
    1296
    
                                                    
                                                
    1297
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1298
        /// Includes error message into revert string on failure.
    1299
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;
    1300
    
                                                    
                                                
    1301
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1302
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;
    1303
    
                                                    
                                                
    1304
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1305
        /// Includes error message into revert string on failure.
    1306
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;
    1307
    
                                                    
                                                
    1308
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1309
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1310
        /// Formats values with decimals in failure message.
    1311
        function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)
    1312
            external
    1313
            pure;
    1314
    
                                                    
                                                
    1315
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1316
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1317
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1318
        function assertApproxEqRelDecimal(
    1319
            uint256 left,
    1320
            uint256 right,
    1321
            uint256 maxPercentDelta,
    1322
            uint256 decimals,
    1323
            string calldata error
    1324
        ) external pure;
    1325
    
                                                    
                                                
    1326
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1327
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1328
        /// Formats values with decimals in failure message.
    1329
        function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)
    1330
            external
    1331
            pure;
    1332
    
                                                    
                                                
    1333
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1334
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1335
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1336
        function assertApproxEqRelDecimal(
    1337
            int256 left,
    1338
            int256 right,
    1339
            uint256 maxPercentDelta,
    1340
            uint256 decimals,
    1341
            string calldata error
    1342
        ) external pure;
    1343
    
                                                    
                                                
    1344
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1345
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1346
        function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;
    1347
    
                                                    
                                                
    1348
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1349
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1350
        /// Includes error message into revert string on failure.
    1351
        function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)
    1352
            external
    1353
            pure;
    1354
    
                                                    
                                                
    1355
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1356
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1357
        function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;
    1358
    
                                                    
                                                
    1359
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1360
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1361
        /// Includes error message into revert string on failure.
    1362
        function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)
    1363
            external
    1364
            pure;
    1365
    
                                                    
                                                
    1366
        /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.
    1367
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1368
    
                                                    
                                                
    1369
        /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.
    1370
        /// Includes error message into revert string on failure.
    1371
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1372
    
                                                    
                                                
    1373
        /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.
    1374
        function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1375
    
                                                    
                                                
    1376
        /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.
    1377
        /// Includes error message into revert string on failure.
    1378
        function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1379
    
                                                    
                                                
    1380
        /// Asserts that two `bool` values are equal.
    1381
        function assertEq(bool left, bool right) external pure;
    1382
    
                                                    
                                                
    1383
        /// Asserts that two `bool` values are equal and includes error message into revert string on failure.
    1384
        function assertEq(bool left, bool right, string calldata error) external pure;
    1385
    
                                                    
                                                
    1386
        /// Asserts that two `string` values are equal.
    1387
        function assertEq(string calldata left, string calldata right) external pure;
    1388
    
                                                    
                                                
    1389
        /// Asserts that two `string` values are equal and includes error message into revert string on failure.
    1390
        function assertEq(string calldata left, string calldata right, string calldata error) external pure;
    1391
    
                                                    
                                                
    1392
        /// Asserts that two `bytes` values are equal.
    1393
        function assertEq(bytes calldata left, bytes calldata right) external pure;
    1394
    
                                                    
                                                
    1395
        /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.
    1396
        function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;
    1397
    
                                                    
                                                
    1398
        /// Asserts that two arrays of `bool` values are equal.
    1399
        function assertEq(bool[] calldata left, bool[] calldata right) external pure;
    1400
    
                                                    
                                                
    1401
        /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.
    1402
        function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;
    1403
    
                                                    
                                                
    1404
        /// Asserts that two arrays of `uint256 values are equal.
    1405
        function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;
    1406
    
                                                    
                                                
    1407
        /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.
    1408
        function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;
    1409
    
                                                    
                                                
    1410
        /// Asserts that two arrays of `int256` values are equal.
    1411
        function assertEq(int256[] calldata left, int256[] calldata right) external pure;
    1412
    
                                                    
                                                
    1413
        /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.
    1414
        function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;
    1415
    
                                                    
                                                
    1416
        /// Asserts that two `uint256` values are equal.
    1417
        function assertEq(uint256 left, uint256 right) external pure;
    1418
    
                                                    
                                                
    1419
        /// Asserts that two arrays of `address` values are equal.
    1420
        function assertEq(address[] calldata left, address[] calldata right) external pure;
    1421
    
                                                    
                                                
    1422
        /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.
    1423
        function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;
    1424
    
                                                    
                                                
    1425
        /// Asserts that two arrays of `bytes32` values are equal.
    1426
        function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;
    1427
    
                                                    
                                                
    1428
        /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.
    1429
        function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;
    1430
    
                                                    
                                                
    1431
        /// Asserts that two arrays of `string` values are equal.
    1432
        function assertEq(string[] calldata left, string[] calldata right) external pure;
    1433
    
                                                    
                                                
    1434
        /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.
    1435
        function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;
    1436
    
                                                    
                                                
    1437
        /// Asserts that two arrays of `bytes` values are equal.
    1438
        function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;
    1439
    
                                                    
                                                
    1440
        /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.
    1441
        function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;
    1442
    
                                                    
                                                
    1443
        /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.
    1444
        function assertEq(uint256 left, uint256 right, string calldata error) external pure;
    1445
    
                                                    
                                                
    1446
        /// Asserts that two `int256` values are equal.
    1447
        function assertEq(int256 left, int256 right) external pure;
    1448
    
                                                    
                                                
    1449
        /// Asserts that two `int256` values are equal and includes error message into revert string on failure.
    1450
        function assertEq(int256 left, int256 right, string calldata error) external pure;
    1451
    
                                                    
                                                
    1452
        /// Asserts that two `address` values are equal.
    1453
        function assertEq(address left, address right) external pure;
    1454
    
                                                    
                                                
    1455
        /// Asserts that two `address` values are equal and includes error message into revert string on failure.
    1456
        function assertEq(address left, address right, string calldata error) external pure;
    1457
    
                                                    
                                                
    1458
        /// Asserts that two `bytes32` values are equal.
    1459
        function assertEq(bytes32 left, bytes32 right) external pure;
    1460
    
                                                    
                                                
    1461
        /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.
    1462
        function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;
    1463
    
                                                    
                                                
    1464
        /// Asserts that the given condition is false.
    1465
        function assertFalse(bool condition) external pure;
    1466
    
                                                    
                                                
    1467
        /// Asserts that the given condition is false and includes error message into revert string on failure.
    1468
        function assertFalse(bool condition, string calldata error) external pure;
    1469
    
                                                    
                                                
    1470
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1471
        /// Formats values with decimals in failure message.
    1472
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1473
    
                                                    
                                                
    1474
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1475
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1476
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1477
    
                                                    
                                                
    1478
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1479
        /// Formats values with decimals in failure message.
    1480
        function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1481
    
                                                    
                                                
    1482
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1483
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1484
        function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1485
    
                                                    
                                                
    1486
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1487
        function assertGe(uint256 left, uint256 right) external pure;
    1488
    
                                                    
                                                
    1489
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1490
        /// Includes error message into revert string on failure.
    1491
        function assertGe(uint256 left, uint256 right, string calldata error) external pure;
    1492
    
                                                    
                                                
    1493
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1494
        function assertGe(int256 left, int256 right) external pure;
    1495
    
                                                    
                                                
    1496
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1497
        /// Includes error message into revert string on failure.
    1498
        function assertGe(int256 left, int256 right, string calldata error) external pure;
    1499
    
                                                    
                                                
    1500
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1501
        /// Formats values with decimals in failure message.
    1502
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1503
    
                                                    
                                                
    1504
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1505
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1506
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1507
    
                                                    
                                                
    1508
        /// Compares two `int256` values. Expects first value to be greater than second.
    1509
        /// Formats values with decimals in failure message.
    1510
        function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1511
    
                                                    
                                                
    1512
        /// Compares two `int256` values. Expects first value to be greater than second.
    1513
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1514
        function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1515
    
                                                    
                                                
    1516
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1517
        function assertGt(uint256 left, uint256 right) external pure;
    1518
    
                                                    
                                                
    1519
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1520
        /// Includes error message into revert string on failure.
    1521
        function assertGt(uint256 left, uint256 right, string calldata error) external pure;
    1522
    
                                                    
                                                
    1523
        /// Compares two `int256` values. Expects first value to be greater than second.
    1524
        function assertGt(int256 left, int256 right) external pure;
    1525
    
                                                    
                                                
    1526
        /// Compares two `int256` values. Expects first value to be greater than second.
    1527
        /// Includes error message into revert string on failure.
    1528
        function assertGt(int256 left, int256 right, string calldata error) external pure;
    1529
    
                                                    
                                                
    1530
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1531
        /// Formats values with decimals in failure message.
    1532
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1533
    
                                                    
                                                
    1534
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1535
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1536
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1537
    
                                                    
                                                
    1538
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1539
        /// Formats values with decimals in failure message.
    1540
        function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1541
    
                                                    
                                                
    1542
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1543
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1544
        function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1545
    
                                                    
                                                
    1546
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1547
        function assertLe(uint256 left, uint256 right) external pure;
    1548
    
                                                    
                                                
    1549
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1550
        /// Includes error message into revert string on failure.
    1551
        function assertLe(uint256 left, uint256 right, string calldata error) external pure;
    1552
    
                                                    
                                                
    1553
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1554
        function assertLe(int256 left, int256 right) external pure;
    1555
    
                                                    
                                                
    1556
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1557
        /// Includes error message into revert string on failure.
    1558
        function assertLe(int256 left, int256 right, string calldata error) external pure;
    1559
    
                                                    
                                                
    1560
        /// Compares two `uint256` values. Expects first value to be less than second.
    1561
        /// Formats values with decimals in failure message.
    1562
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1563
    
                                                    
                                                
    1564
        /// Compares two `uint256` values. Expects first value to be less than second.
    1565
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1566
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1567
    
                                                    
                                                
    1568
        /// Compares two `int256` values. Expects first value to be less than second.
    1569
        /// Formats values with decimals in failure message.
    1570
        function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1571
    
                                                    
                                                
    1572
        /// Compares two `int256` values. Expects first value to be less than second.
    1573
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1574
        function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1575
    
                                                    
                                                
    1576
        /// Compares two `uint256` values. Expects first value to be less than second.
    1577
        function assertLt(uint256 left, uint256 right) external pure;
    1578
    
                                                    
                                                
    1579
        /// Compares two `uint256` values. Expects first value to be less than second.
    1580
        /// Includes error message into revert string on failure.
    1581
        function assertLt(uint256 left, uint256 right, string calldata error) external pure;
    1582
    
                                                    
                                                
    1583
        /// Compares two `int256` values. Expects first value to be less than second.
    1584
        function assertLt(int256 left, int256 right) external pure;
    1585
    
                                                    
                                                
    1586
        /// Compares two `int256` values. Expects first value to be less than second.
    1587
        /// Includes error message into revert string on failure.
    1588
        function assertLt(int256 left, int256 right, string calldata error) external pure;
    1589
    
                                                    
                                                
    1590
        /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.
    1591
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1592
    
                                                    
                                                
    1593
        /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.
    1594
        /// Includes error message into revert string on failure.
    1595
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1596
    
                                                    
                                                
    1597
        /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.
    1598
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1599
    
                                                    
                                                
    1600
        /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.
    1601
        /// Includes error message into revert string on failure.
    1602
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1603
    
                                                    
                                                
    1604
        /// Asserts that two `bool` values are not equal.
    1605
        function assertNotEq(bool left, bool right) external pure;
    1606
    
                                                    
                                                
    1607
        /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.
    1608
        function assertNotEq(bool left, bool right, string calldata error) external pure;
    1609
    
                                                    
                                                
    1610
        /// Asserts that two `string` values are not equal.
    1611
        function assertNotEq(string calldata left, string calldata right) external pure;
    1612
    
                                                    
                                                
    1613
        /// Asserts that two `string` values are not equal and includes error message into revert string on failure.
    1614
        function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;
    1615
    
                                                    
                                                
    1616
        /// Asserts that two `bytes` values are not equal.
    1617
        function assertNotEq(bytes calldata left, bytes calldata right) external pure;
    1618
    
                                                    
                                                
    1619
        /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.
    1620
        function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;
    1621
    
                                                    
                                                
    1622
        /// Asserts that two arrays of `bool` values are not equal.
    1623
        function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;
    1624
    
                                                    
                                                
    1625
        /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.
    1626
        function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;
    1627
    
                                                    
                                                
    1628
        /// Asserts that two arrays of `uint256` values are not equal.
    1629
        function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;
    1630
    
                                                    
                                                
    1631
        /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.
    1632
        function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;
    1633
    
                                                    
                                                
    1634
        /// Asserts that two arrays of `int256` values are not equal.
    1635
        function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;
    1636
    
                                                    
                                                
    1637
        /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.
    1638
        function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;
    1639
    
                                                    
                                                
    1640
        /// Asserts that two `uint256` values are not equal.
    1641
        function assertNotEq(uint256 left, uint256 right) external pure;
    1642
    
                                                    
                                                
    1643
        /// Asserts that two arrays of `address` values are not equal.
    1644
        function assertNotEq(address[] calldata left, address[] calldata right) external pure;
    1645
    
                                                    
                                                
    1646
        /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.
    1647
        function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;
    1648
    
                                                    
                                                
    1649
        /// Asserts that two arrays of `bytes32` values are not equal.
    1650
        function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;
    1651
    
                                                    
                                                
    1652
        /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.
    1653
        function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;
    1654
    
                                                    
                                                
    1655
        /// Asserts that two arrays of `string` values are not equal.
    1656
        function assertNotEq(string[] calldata left, string[] calldata right) external pure;
    1657
    
                                                    
                                                
    1658
        /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.
    1659
        function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;
    1660
    
                                                    
                                                
    1661
        /// Asserts that two arrays of `bytes` values are not equal.
    1662
        function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;
    1663
    
                                                    
                                                
    1664
        /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.
    1665
        function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;
    1666
    
                                                    
                                                
    1667
        /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.
    1668
        function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;
    1669
    
                                                    
                                                
    1670
        /// Asserts that two `int256` values are not equal.
    1671
        function assertNotEq(int256 left, int256 right) external pure;
    1672
    
                                                    
                                                
    1673
        /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.
    1674
        function assertNotEq(int256 left, int256 right, string calldata error) external pure;
    1675
    
                                                    
                                                
    1676
        /// Asserts that two `address` values are not equal.
    1677
        function assertNotEq(address left, address right) external pure;
    1678
    
                                                    
                                                
    1679
        /// Asserts that two `address` values are not equal and includes error message into revert string on failure.
    1680
        function assertNotEq(address left, address right, string calldata error) external pure;
    1681
    
                                                    
                                                
    1682
        /// Asserts that two `bytes32` values are not equal.
    1683
        function assertNotEq(bytes32 left, bytes32 right) external pure;
    1684
    
                                                    
                                                
    1685
        /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.
    1686
        function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;
    1687
    
                                                    
                                                
    1688
        /// Asserts that the given condition is true.
    1689
        function assertTrue(bool condition) external pure;
    1690
    
                                                    
                                                
    1691
        /// Asserts that the given condition is true and includes error message into revert string on failure.
    1692
        function assertTrue(bool condition, string calldata error) external pure;
    1693
    
                                                    
                                                
    1694
        /// If the condition is false, discard this run's fuzz inputs and generate new ones.
    1695
        function assume(bool condition) external pure;
    1696
    
                                                    
                                                
    1697
        /// Discard this run's fuzz inputs and generate new ones if next call reverted.
    1698
        function assumeNoRevert() external pure;
    1699
    
                                                    
                                                
    1700
        /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.
    1701
        function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;
    1702
    
                                                    
                                                
    1703
        /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.
    1704
        function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;
    1705
    
                                                    
                                                
    1706
        /// Writes a breakpoint to jump to in the debugger.
    1707
        function breakpoint(string calldata char) external pure;
    1708
    
                                                    
                                                
    1709
        /// Writes a conditional breakpoint to jump to in the debugger.
    1710
        function breakpoint(string calldata char, bool value) external pure;
    1711
    
                                                    
                                                
    1712
        /// Returns true if the current Foundry version is greater than or equal to the given version.
    1713
        /// The given version string must be in the format `major.minor.patch`.
    1714
        /// This is equivalent to `foundryVersionCmp(version) >= 0`.
    1715
        function foundryVersionAtLeast(string calldata version) external view returns (bool);
    1716
    
                                                    
                                                
    1717
        /// Compares the current Foundry version with the given version string.
    1718
        /// The given version string must be in the format `major.minor.patch`.
    1719
        /// Returns:
    1720
        /// -1 if current Foundry version is less than the given version
    1721
        /// 0 if current Foundry version equals the given version
    1722
        /// 1 if current Foundry version is greater than the given version
    1723
        /// This result can then be used with a comparison operator against `0`.
    1724
        /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:
    1725
        /// `if (foundryVersionCmp("1.0.0") >= 0) { ... }`
    1726
        function foundryVersionCmp(string calldata version) external view returns (int256);
    1727
    
                                                    
                                                
    1728
        /// Returns a Chain struct for specific alias
    1729
        function getChain(string calldata chainAlias) external view returns (Chain memory chain);
    1730
    
                                                    
                                                
    1731
        /// Returns a Chain struct for specific chainId
    1732
        function getChain(uint256 chainId) external view returns (Chain memory chain);
    1733
    
                                                    
                                                
    1734
        /// Returns the Foundry version.
    1735
        /// Format: <cargo_version>-<tag>+<git_sha_short>.<unix_build_timestamp>.<profile>
    1736
        /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug
    1737
        /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.
    1738
        /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)
    1739
        /// to compare timestamps while ignoring minor time differences.
    1740
        function getFoundryVersion() external view returns (string memory version);
    1741
    
                                                    
                                                
    1742
        /// Returns the RPC url for the given alias.
    1743
        function rpcUrl(string calldata rpcAlias) external view returns (string memory json);
    1744
    
                                                    
                                                
    1745
        /// Returns all rpc urls and their aliases as structs.
    1746
        function rpcUrlStructs() external view returns (Rpc[] memory urls);
    1747
    
                                                    
                                                
    1748
        /// Returns all rpc urls and their aliases `[alias, url][]`.
    1749
        function rpcUrls() external view returns (string[2][] memory urls);
    1750
    
                                                    
                                                
    1751
        /// Suspends execution of the main thread for `duration` milliseconds.
    1752
        function sleep(uint256 duration) external;
    1753
    
                                                    
                                                
    1754
        // ======== Toml ========
    1755
    
                                                    
                                                
    1756
        /// Checks if `key` exists in a TOML table.
    1757
        function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);
    1758
    
                                                    
                                                
    1759
        /// Parses a string of TOML data at `key` and coerces it to `address`.
    1760
        function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);
    1761
    
                                                    
                                                
    1762
        /// Parses a string of TOML data at `key` and coerces it to `address[]`.
    1763
        function parseTomlAddressArray(string calldata toml, string calldata key)
    1764
            external
    1765
            pure
    1766
            returns (address[] memory);
    1767
    
                                                    
                                                
    1768
        /// Parses a string of TOML data at `key` and coerces it to `bool`.
    1769
        function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);
    1770
    
                                                    
                                                
    1771
        /// Parses a string of TOML data at `key` and coerces it to `bool[]`.
    1772
        function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);
    1773
    
                                                    
                                                
    1774
        /// Parses a string of TOML data at `key` and coerces it to `bytes`.
    1775
        function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);
    1776
    
                                                    
                                                
    1777
        /// Parses a string of TOML data at `key` and coerces it to `bytes32`.
    1778
        function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);
    1779
    
                                                    
                                                
    1780
        /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.
    1781
        function parseTomlBytes32Array(string calldata toml, string calldata key)
    1782
            external
    1783
            pure
    1784
            returns (bytes32[] memory);
    1785
    
                                                    
                                                
    1786
        /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.
    1787
        function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);
    1788
    
                                                    
                                                
    1789
        /// Parses a string of TOML data at `key` and coerces it to `int256`.
    1790
        function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);
    1791
    
                                                    
                                                
    1792
        /// Parses a string of TOML data at `key` and coerces it to `int256[]`.
    1793
        function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);
    1794
    
                                                    
                                                
    1795
        /// Returns an array of all the keys in a TOML table.
    1796
        function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);
    1797
    
                                                    
                                                
    1798
        /// Parses a string of TOML data at `key` and coerces it to `string`.
    1799
        function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);
    1800
    
                                                    
                                                
    1801
        /// Parses a string of TOML data at `key` and coerces it to `string[]`.
    1802
        function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);
    1803
    
                                                    
                                                
    1804
        /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.
    1805
        function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)
    1806
            external
    1807
            pure
    1808
            returns (bytes memory);
    1809
    
                                                    
                                                
    1810
        /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.
    1811
        function parseTomlType(string calldata toml, string calldata typeDescription)
    1812
            external
    1813
            pure
    1814
            returns (bytes memory);
    1815
    
                                                    
                                                
    1816
        /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.
    1817
        function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)
    1818
            external
    1819
            pure
    1820
            returns (bytes memory);
    1821
    
                                                    
                                                
    1822
        /// Parses a string of TOML data at `key` and coerces it to `uint256`.
    1823
        function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);
    1824
    
                                                    
                                                
    1825
        /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.
    1826
        function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);
    1827
    
                                                    
                                                
    1828
        /// ABI-encodes a TOML table.
    1829
        function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);
    1830
    
                                                    
                                                
    1831
        /// ABI-encodes a TOML table at `key`.
    1832
        function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);
    1833
    
                                                    
                                                
    1834
        /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.
    1835
        function writeToml(string calldata json, string calldata path) external;
    1836
    
                                                    
                                                
    1837
        /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = <value_key.>
    1838
        /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.
    1839
        function writeToml(string calldata json, string calldata path, string calldata valueKey) external;
    1840
    
                                                    
                                                
    1841
        // ======== Utilities ========
    1842
    
                                                    
                                                
    1843
        /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.
    1844
        function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)
    1845
            external
    1846
            pure
    1847
            returns (address);
    1848
    
                                                    
                                                
    1849
        /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.
    1850
        function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);
    1851
    
                                                    
                                                
    1852
        /// Compute the address a contract will be deployed at for a given deployer address and nonce.
    1853
        function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);
    1854
    
                                                    
                                                
    1855
        /// Utility cheatcode to copy storage of `from` contract to another `to` contract.
    1856
        function copyStorage(address from, address to) external;
    1857
    
                                                    
                                                
    1858
        /// Generates the struct hash of the canonical EIP-712 type representation and its abi-encoded data.
    1859
        /// Supports 2 different inputs:
    1860
        /// 1. Name of the type (i.e. "PermitSingle"):
    1861
        /// * requires previous binding generation with `forge bind-json`.
    1862
        /// * bindings will be retrieved from the path configured in `foundry.toml`.
    1863
        /// 2. String representation of the type (i.e. "Foo(Bar bar) Bar(uint256 baz)").
    1864
        /// * Note: the cheatcode will use the canonical type even if the input is malformated
    1865
        /// with the wrong order of elements or with extra whitespaces.
    1866
        function eip712HashStruct(string calldata typeNameOrDefinition, bytes calldata abiEncodedData)
    1867
            external
    1868
            pure
    1869
            returns (bytes32 typeHash);
    1870
    
                                                    
                                                
    1871
        /// Generates the struct hash of the canonical EIP-712 type representation and its abi-encoded data.
    1872
        /// Requires previous binding generation with `forge bind-json`.
    1873
        /// Params:
    1874
        /// * `bindingsPath`: path where the output of `forge bind-json` is stored.
    1875
        /// * `typeName`: Name of the type (i.e. "PermitSingle").
    1876
        /// * `abiEncodedData`: ABI-encoded data for the struct that is being hashed.
    1877
        function eip712HashStruct(string calldata bindingsPath, string calldata typeName, bytes calldata abiEncodedData)
    1878
            external
    1879
            pure
    1880
            returns (bytes32 typeHash);
    1881
    
                                                    
                                                
    1882
        /// Generates the hash of the canonical EIP-712 type representation.
    1883
        /// Supports 2 different inputs:
    1884
        /// 1. Name of the type (i.e. "Transaction"):
    1885
        /// * requires previous binding generation with `forge bind-json`.
    1886
        /// * bindings will be retrieved from the path configured in `foundry.toml`.
    1887
        /// 2. String representation of the type (i.e. "Foo(Bar bar) Bar(uint256 baz)").
    1888
        /// * Note: the cheatcode will output the canonical type even if the input is malformated
    1889
        /// with the wrong order of elements or with extra whitespaces.
    1890
        function eip712HashType(string calldata typeNameOrDefinition) external pure returns (bytes32 typeHash);
    1891
    
                                                    
                                                
    1892
        /// Generates the hash of the canonical EIP-712 type representation.
    1893
        /// Requires previous binding generation with `forge bind-json`.
    1894
        /// Params:
    1895
        /// * `bindingsPath`: path where the output of `forge bind-json` is stored.
    1896
        /// * `typeName`: Name of the type (i.e. "Transaction").
    1897
        function eip712HashType(string calldata bindingsPath, string calldata typeName)
    1898
            external
    1899
            pure
    1900
            returns (bytes32 typeHash);
    1901
    
                                                    
                                                
    1902
        /// Generates a ready-to-sign digest of human-readable typed data following the EIP-712 standard.
    1903
        function eip712HashTypedData(string calldata jsonData) external pure returns (bytes32 digest);
    1904
    
                                                    
                                                
    1905
        /// Returns ENS namehash for provided string.
    1906
        function ensNamehash(string calldata name) external pure returns (bytes32);
    1907
    
                                                    
                                                
    1908
        /// Gets the label for the specified address.
    1909
        function getLabel(address account) external view returns (string memory currentLabel);
    1910
    
                                                    
                                                
    1911
        /// Labels an address in call traces.
    1912
        function label(address account, string calldata newLabel) external;
    1913
    
                                                    
                                                
    1914
        /// Pauses collection of call traces. Useful in cases when you want to skip tracing of
    1915
        /// complex calls which are not useful for debugging.
    1916
        function pauseTracing() external view;
    1917
    
                                                    
                                                
    1918
        /// Returns a random `address`.
    1919
        function randomAddress() external view returns (address);
    1920
    
                                                    
                                                
    1921
        /// Returns a random `bool`.
    1922
        function randomBool() external view returns (bool);
    1923
    
                                                    
                                                
    1924
        /// Returns a random byte array value of the given length.
    1925
        function randomBytes(uint256 len) external view returns (bytes memory);
    1926
    
                                                    
                                                
    1927
        /// Returns a random fixed-size byte array of length 4.
    1928
        function randomBytes4() external view returns (bytes4);
    1929
    
                                                    
                                                
    1930
        /// Returns a random fixed-size byte array of length 8.
    1931
        function randomBytes8() external view returns (bytes8);
    1932
    
                                                    
                                                
    1933
        /// Returns a random `int256` value.
    1934
        function randomInt() external view returns (int256);
    1935
    
                                                    
                                                
    1936
        /// Returns a random `int256` value of given bits.
    1937
        function randomInt(uint256 bits) external view returns (int256);
    1938
    
                                                    
                                                
    1939
        /// Returns a random uint256 value.
    1940
        function randomUint() external view returns (uint256);
    1941
    
                                                    
                                                
    1942
        /// Returns random uint256 value between the provided range (=min..=max).
    1943
        function randomUint(uint256 min, uint256 max) external view returns (uint256);
    1944
    
                                                    
                                                
    1945
        /// Returns a random `uint256` value of given bits.
    1946
        function randomUint(uint256 bits) external view returns (uint256);
    1947
    
                                                    
                                                
    1948
        /// Unpauses collection of call traces.
    1949
        function resumeTracing() external view;
    1950
    
                                                    
                                                
    1951
        /// Utility cheatcode to set arbitrary storage for given target address.
    1952
        function setArbitraryStorage(address target) external;
    1953
    
                                                    
                                                
    1954
        /// Utility cheatcode to set arbitrary storage for given target address and overwrite
    1955
        /// any storage slots that have been previously set.
    1956
        function setArbitraryStorage(address target, bool overwrite) external;
    1957
    
                                                    
                                                
    1958
        /// Set RNG seed.
    1959
        function setSeed(uint256 seed) external;
    1960
    
                                                    
                                                
    1961
        /// Randomly shuffles an array.
    1962
        function shuffle(uint256[] calldata array) external returns (uint256[] memory);
    1963
    
                                                    
                                                
    1964
        /// Sorts an array in ascending order.
    1965
        function sort(uint256[] calldata array) external returns (uint256[] memory);
    1966
    
                                                    
                                                
    1967
        /// Encodes a `bytes` value to a base64url string.
    1968
        function toBase64URL(bytes calldata data) external pure returns (string memory);
    1969
    
                                                    
                                                
    1970
        /// Encodes a `string` value to a base64url string.
    1971
        function toBase64URL(string calldata data) external pure returns (string memory);
    1972
    
                                                    
                                                
    1973
        /// Encodes a `bytes` value to a base64 string.
    1974
        function toBase64(bytes calldata data) external pure returns (string memory);
    1975
    
                                                    
                                                
    1976
        /// Encodes a `string` value to a base64 string.
    1977
        function toBase64(string calldata data) external pure returns (string memory);
    1978
    }
    1979
    
                                                    
                                                
    1980
    /// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used
    1981
    /// in tests, but it is not recommended to use these cheats in scripts.
    1982
    interface Vm is VmSafe {
    1983
        // ======== EVM ========
    1984
    
                                                    
                                                
    1985
        /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.
    1986
        function accessList(AccessListItem[] calldata access) external;
    1987
    
                                                    
                                                
    1988
        /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.
    1989
        function activeFork() external view returns (uint256 forkId);
    1990
    
                                                    
                                                
    1991
        /// In forking mode, explicitly grant the given address cheatcode access.
    1992
        function allowCheatcodes(address account) external;
    1993
    
                                                    
                                                
    1994
        /// Sets `block.blobbasefee`
    1995
        function blobBaseFee(uint256 newBlobBaseFee) external;
    1996
    
                                                    
                                                
    1997
        /// Sets the blobhashes in the transaction.
    1998
        /// Not available on EVM versions before Cancun.
    1999
        /// If used on unsupported EVM versions it will revert.
    2000
        function blobhashes(bytes32[] calldata hashes) external;
    2001
    
                                                    
                                                
    2002
        /// Sets `block.chainid`.
    2003
        function chainId(uint256 newChainId) external;
    2004
    
                                                    
                                                
    2005
        /// Clears all mocked calls.
    2006
        function clearMockedCalls() external;
    2007
    
                                                    
                                                
    2008
        /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.
    2009
        function cloneAccount(address source, address target) external;
    2010
    
                                                    
                                                
    2011
        /// Sets `block.coinbase`.
    2012
        function coinbase(address newCoinbase) external;
    2013
    
                                                    
                                                
    2014
        /// Marks the slots of an account and the account address as cold.
    2015
        function cool(address target) external;
    2016
    
                                                    
                                                
    2017
        /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.
    2018
        function coolSlot(address target, bytes32 slot) external;
    2019
    
                                                    
                                                
    2020
        /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.
    2021
        function createFork(string calldata urlOrAlias) external returns (uint256 forkId);
    2022
    
                                                    
                                                
    2023
        /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.
    2024
        function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);
    2025
    
                                                    
                                                
    2026
        /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,
    2027
        /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.
    2028
        function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);
    2029
    
                                                    
                                                
    2030
        /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.
    2031
        function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);
    2032
    
                                                    
                                                
    2033
        /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.
    2034
        function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);
    2035
    
                                                    
                                                
    2036
        /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,
    2037
        /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.
    2038
        function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);
    2039
    
                                                    
                                                
    2040
        /// Sets an address' balance.
    2041
        function deal(address account, uint256 newBalance) external;
    2042
    
                                                    
                                                
    2043
        /// Removes the snapshot with the given ID created by `snapshot`.
    2044
        /// Takes the snapshot ID to delete.
    2045
        /// Returns `true` if the snapshot was successfully deleted.
    2046
        /// Returns `false` if the snapshot does not exist.
    2047
        function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);
    2048
    
                                                    
                                                
    2049
        /// Removes _all_ snapshots previously created by `snapshot`.
    2050
        function deleteStateSnapshots() external;
    2051
    
                                                    
                                                
    2052
        /// Sets `block.difficulty`.
    2053
        /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.
    2054
        /// Reverts if used on unsupported EVM versions.
    2055
        function difficulty(uint256 newDifficulty) external;
    2056
    
                                                    
                                                
    2057
        /// Dump a genesis JSON file's `allocs` to disk.
    2058
        function dumpState(string calldata pathToStateJson) external;
    2059
    
                                                    
                                                
    2060
        /// Sets an address' code.
    2061
        function etch(address target, bytes calldata newRuntimeBytecode) external;
    2062
    
                                                    
                                                
    2063
        /// Sets `block.basefee`.
    2064
        function fee(uint256 newBasefee) external;
    2065
    
                                                    
                                                
    2066
        /// Gets the blockhashes from the current transaction.
    2067
        /// Not available on EVM versions before Cancun.
    2068
        /// If used on unsupported EVM versions it will revert.
    2069
        function getBlobhashes() external view returns (bytes32[] memory hashes);
    2070
    
                                                    
                                                
    2071
        /// Returns true if the account is marked as persistent.
    2072
        function isPersistent(address account) external view returns (bool persistent);
    2073
    
                                                    
                                                
    2074
        /// Load a genesis JSON file's `allocs` into the in-memory EVM state.
    2075
        function loadAllocs(string calldata pathToAllocsJson) external;
    2076
    
                                                    
                                                
    2077
        /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
    2078
        /// Meaning, changes made to the state of this account will be kept when switching forks.
    2079
        function makePersistent(address account) external;
    2080
    
                                                    
                                                
    2081
        /// See `makePersistent(address)`.
    2082
        function makePersistent(address account0, address account1) external;
    2083
    
                                                    
                                                
    2084
        /// See `makePersistent(address)`.
    2085
        function makePersistent(address account0, address account1, address account2) external;
    2086
    
                                                    
                                                
    2087
        /// See `makePersistent(address)`.
    2088
        function makePersistent(address[] calldata accounts) external;
    2089
    
                                                    
                                                
    2090
        /// Reverts a call to an address with specified revert data.
    2091
        function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;
    2092
    
                                                    
                                                
    2093
        /// Reverts a call to an address with a specific `msg.value`, with specified revert data.
    2094
        function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)
    2095
            external;
    2096
    
                                                    
                                                
    2097
        /// Reverts a call to an address with specified revert data.
    2098
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    2099
        function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;
    2100
    
                                                    
                                                
    2101
        /// Reverts a call to an address with a specific `msg.value`, with specified revert data.
    2102
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    2103
        function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;
    2104
    
                                                    
                                                
    2105
        /// Mocks a call to an address, returning specified data.
    2106
        /// Calldata can either be strict or a partial match, e.g. if you only
    2107
        /// pass a Solidity selector to the expected calldata, then the entire Solidity
    2108
        /// function will be mocked.
    2109
        function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;
    2110
    
                                                    
                                                
    2111
        /// Mocks a call to an address with a specific `msg.value`, returning specified data.
    2112
        /// Calldata match takes precedence over `msg.value` in case of ambiguity.
    2113
        function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;
    2114
    
                                                    
                                                
    2115
        /// Mocks a call to an address, returning specified data.
    2116
        /// Calldata can either be strict or a partial match, e.g. if you only
    2117
        /// pass a Solidity selector to the expected calldata, then the entire Solidity
    2118
        /// function will be mocked.
    2119
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    2120
        function mockCall(address callee, bytes4 data, bytes calldata returnData) external;
    2121
    
                                                    
                                                
    2122
        /// Mocks a call to an address with a specific `msg.value`, returning specified data.
    2123
        /// Calldata match takes precedence over `msg.value` in case of ambiguity.
    2124
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    2125
        function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;
    2126
    
                                                    
                                                
    2127
        /// Mocks multiple calls to an address, returning specified data for each call.
    2128
        function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;
    2129
    
                                                    
                                                
    2130
        /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.
    2131
        function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;
    2132
    
                                                    
                                                
    2133
        /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls
    2134
        /// `target` with the same calldata. This functionality is similar to a delegate call made to
    2135
        /// `target` contract from `callee`.
    2136
        /// Can be used to substitute a call to a function with another implementation that captures
    2137
        /// the primary logic of the original function but is easier to reason about.
    2138
        /// If calldata is not a strict match then partial match by selector is attempted.
    2139
        function mockFunction(address callee, address target, bytes calldata data) external;
    2140
    
                                                    
                                                
    2141
        /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.
    2142
        function noAccessList() external;
    2143
    
                                                    
                                                
    2144
        /// Sets the *next* call's `msg.sender` to be the input address.
    2145
        function prank(address msgSender) external;
    2146
    
                                                    
                                                
    2147
        /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.
    2148
        function prank(address msgSender, address txOrigin) external;
    2149
    
                                                    
                                                
    2150
        /// Sets the *next* delegate call's `msg.sender` to be the input address.
    2151
        function prank(address msgSender, bool delegateCall) external;
    2152
    
                                                    
                                                
    2153
        /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.
    2154
        function prank(address msgSender, address txOrigin, bool delegateCall) external;
    2155
    
                                                    
                                                
    2156
        /// Sets `block.prevrandao`.
    2157
        /// Not available on EVM versions before Paris. Use `difficulty` instead.
    2158
        /// If used on unsupported EVM versions it will revert.
    2159
        function prevrandao(bytes32 newPrevrandao) external;
    2160
    
                                                    
                                                
    2161
        /// Sets `block.prevrandao`.
    2162
        /// Not available on EVM versions before Paris. Use `difficulty` instead.
    2163
        /// If used on unsupported EVM versions it will revert.
    2164
        function prevrandao(uint256 newPrevrandao) external;
    2165
    
                                                    
                                                
    2166
        /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.
    2167
        function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);
    2168
    
                                                    
                                                
    2169
        /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.
    2170
        function resetNonce(address account) external;
    2171
    
                                                    
                                                
    2172
        /// Revert the state of the EVM to a previous snapshot
    2173
        /// Takes the snapshot ID to revert to.
    2174
        /// Returns `true` if the snapshot was successfully reverted.
    2175
        /// Returns `false` if the snapshot does not exist.
    2176
        /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.
    2177
        function revertToState(uint256 snapshotId) external returns (bool success);
    2178
    
                                                    
                                                
    2179
        /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots
    2180
        /// Takes the snapshot ID to revert to.
    2181
        /// Returns `true` if the snapshot was successfully reverted and deleted.
    2182
        /// Returns `false` if the snapshot does not exist.
    2183
        function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);
    2184
    
                                                    
                                                
    2185
        /// Revokes persistent status from the address, previously added via `makePersistent`.
    2186
        function revokePersistent(address account) external;
    2187
    
                                                    
                                                
    2188
        /// See `revokePersistent(address)`.
    2189
        function revokePersistent(address[] calldata accounts) external;
    2190
    
                                                    
                                                
    2191
        /// Sets `block.height`.
    2192
        function roll(uint256 newHeight) external;
    2193
    
                                                    
                                                
    2194
        /// Updates the currently active fork to given block number
    2195
        /// This is similar to `roll` but for the currently active fork.
    2196
        function rollFork(uint256 blockNumber) external;
    2197
    
                                                    
                                                
    2198
        /// Updates the currently active fork to given transaction. This will `rollFork` with the number
    2199
        /// of the block the transaction was mined in and replays all transaction mined before it in the block.
    2200
        function rollFork(bytes32 txHash) external;
    2201
    
                                                    
                                                
    2202
        /// Updates the given fork to given block number.
    2203
        function rollFork(uint256 forkId, uint256 blockNumber) external;
    2204
    
                                                    
                                                
    2205
        /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.
    2206
        function rollFork(uint256 forkId, bytes32 txHash) external;
    2207
    
                                                    
                                                
    2208
        /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
    2209
        function selectFork(uint256 forkId) external;
    2210
    
                                                    
                                                
    2211
        /// Set blockhash for the current block.
    2212
        /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.
    2213
        function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;
    2214
    
                                                    
                                                
    2215
        /// Sets the nonce of an account. Must be higher than the current nonce of the account.
    2216
        function setNonce(address account, uint64 newNonce) external;
    2217
    
                                                    
                                                
    2218
        /// Sets the nonce of an account to an arbitrary value.
    2219
        function setNonceUnsafe(address account, uint64 newNonce) external;
    2220
    
                                                    
                                                
    2221
        /// Snapshot capture the gas usage of the last call by name from the callee perspective.
    2222
        function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);
    2223
    
                                                    
                                                
    2224
        /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.
    2225
        function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);
    2226
    
                                                    
                                                
    2227
        /// Snapshot the current state of the evm.
    2228
        /// Returns the ID of the snapshot that was created.
    2229
        /// To revert a snapshot use `revertToState`.
    2230
        function snapshotState() external returns (uint256 snapshotId);
    2231
    
                                                    
                                                
    2232
        /// Snapshot capture an arbitrary numerical value by name.
    2233
        /// The group name is derived from the contract name.
    2234
        function snapshotValue(string calldata name, uint256 value) external;
    2235
    
                                                    
                                                
    2236
        /// Snapshot capture an arbitrary numerical value by name in a group.
    2237
        function snapshotValue(string calldata group, string calldata name, uint256 value) external;
    2238
    
                                                    
                                                
    2239
        /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.
    2240
        function startPrank(address msgSender) external;
    2241
    
                                                    
                                                
    2242
        /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.
    2243
        function startPrank(address msgSender, address txOrigin) external;
    2244
    
                                                    
                                                
    2245
        /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.
    2246
        function startPrank(address msgSender, bool delegateCall) external;
    2247
    
                                                    
                                                
    2248
        /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.
    2249
        function startPrank(address msgSender, address txOrigin, bool delegateCall) external;
    2250
    
                                                    
                                                
    2251
        /// Start a snapshot capture of the current gas usage by name.
    2252
        /// The group name is derived from the contract name.
    2253
        function startSnapshotGas(string calldata name) external;
    2254
    
                                                    
                                                
    2255
        /// Start a snapshot capture of the current gas usage by name in a group.
    2256
        function startSnapshotGas(string calldata group, string calldata name) external;
    2257
    
                                                    
                                                
    2258
        /// Resets subsequent calls' `msg.sender` to be `address(this)`.
    2259
        function stopPrank() external;
    2260
    
                                                    
                                                
    2261
        /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.
    2262
        function stopSnapshotGas() external returns (uint256 gasUsed);
    2263
    
                                                    
                                                
    2264
        /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.
    2265
        /// The group name is derived from the contract name.
    2266
        function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);
    2267
    
                                                    
                                                
    2268
        /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.
    2269
        function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);
    2270
    
                                                    
                                                
    2271
        /// Stores a value to an address' storage slot.
    2272
        function store(address target, bytes32 slot, bytes32 value) external;
    2273
    
                                                    
                                                
    2274
        /// Fetches the given transaction from the active fork and executes it on the current state.
    2275
        function transact(bytes32 txHash) external;
    2276
    
                                                    
                                                
    2277
        /// Fetches the given transaction from the given fork and executes it on the current state.
    2278
        function transact(uint256 forkId, bytes32 txHash) external;
    2279
    
                                                    
                                                
    2280
        /// Sets `tx.gasprice`.
    2281
        function txGasPrice(uint256 newGasPrice) external;
    2282
    
                                                    
                                                
    2283
        /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.
    2284
        function warmSlot(address target, bytes32 slot) external;
    2285
    
                                                    
                                                
    2286
        /// Sets `block.timestamp`.
    2287
        function warp(uint256 newTimestamp) external;
    2288
    
                                                    
                                                
    2289
        /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.
    2290
        function deleteSnapshot(uint256 snapshotId) external returns (bool success);
    2291
    
                                                    
                                                
    2292
        /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.
    2293
        function deleteSnapshots() external;
    2294
    
                                                    
                                                
    2295
        /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.
    2296
        function revertToAndDelete(uint256 snapshotId) external returns (bool success);
    2297
    
                                                    
                                                
    2298
        /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.
    2299
        function revertTo(uint256 snapshotId) external returns (bool success);
    2300
    
                                                    
                                                
    2301
        /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.
    2302
        function snapshot() external returns (uint256 snapshotId);
    2303
    
                                                    
                                                
    2304
        // ======== Testing ========
    2305
    
                                                    
                                                
    2306
        /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.
    2307
        function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;
    2308
    
                                                    
                                                
    2309
        /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.
    2310
        function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)
    2311
            external;
    2312
    
                                                    
                                                
    2313
        /// Expects a call to an address with the specified calldata.
    2314
        /// Calldata can either be a strict or a partial match.
    2315
        function expectCall(address callee, bytes calldata data) external;
    2316
    
                                                    
                                                
    2317
        /// Expects given number of calls to an address with the specified calldata.
    2318
        function expectCall(address callee, bytes calldata data, uint64 count) external;
    2319
    
                                                    
                                                
    2320
        /// Expects a call to an address with the specified `msg.value` and calldata.
    2321
        function expectCall(address callee, uint256 msgValue, bytes calldata data) external;
    2322
    
                                                    
                                                
    2323
        /// Expects given number of calls to an address with the specified `msg.value` and calldata.
    2324
        function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;
    2325
    
                                                    
                                                
    2326
        /// Expect a call to an address with the specified `msg.value`, gas, and calldata.
    2327
        function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;
    2328
    
                                                    
                                                
    2329
        /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.
    2330
        function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;
    2331
    
                                                    
                                                
    2332
        /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode
    2333
        function expectCreate(bytes calldata bytecode, address deployer) external;
    2334
    
                                                    
                                                
    2335
        /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode
    2336
        function expectCreate2(bytes calldata bytecode, address deployer) external;
    2337
    
                                                    
                                                
    2338
        /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).
    2339
        /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if
    2340
        /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).
    2341
        function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)
    2342
            external;
    2343
    
                                                    
                                                
    2344
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2345
        function expectEmitAnonymous(
    2346
            bool checkTopic0,
    2347
            bool checkTopic1,
    2348
            bool checkTopic2,
    2349
            bool checkTopic3,
    2350
            bool checkData,
    2351
            address emitter
    2352
        ) external;
    2353
    
                                                    
                                                
    2354
        /// Prepare an expected anonymous log with all topic and data checks enabled.
    2355
        /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if
    2356
        /// logs were emitted in the expected order with the expected topics and data.
    2357
        function expectEmitAnonymous() external;
    2358
    
                                                    
                                                
    2359
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2360
        function expectEmitAnonymous(address emitter) external;
    2361
    
                                                    
                                                
    2362
        /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).
    2363
        /// Call this function, then emit an event, then call a function. Internally after the call, we check if
    2364
        /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).
    2365
        function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;
    2366
    
                                                    
                                                
    2367
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2368
        function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)
    2369
            external;
    2370
    
                                                    
                                                
    2371
        /// Prepare an expected log with all topic and data checks enabled.
    2372
        /// Call this function, then emit an event, then call a function. Internally after the call, we check if
    2373
        /// logs were emitted in the expected order with the expected topics and data.
    2374
        function expectEmit() external;
    2375
    
                                                    
                                                
    2376
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2377
        function expectEmit(address emitter) external;
    2378
    
                                                    
                                                
    2379
        /// Expect a given number of logs with the provided topics.
    2380
        function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;
    2381
    
                                                    
                                                
    2382
        /// Expect a given number of logs from a specific emitter with the provided topics.
    2383
        function expectEmit(
    2384
            bool checkTopic1,
    2385
            bool checkTopic2,
    2386
            bool checkTopic3,
    2387
            bool checkData,
    2388
            address emitter,
    2389
            uint64 count
    2390
        ) external;
    2391
    
                                                    
                                                
    2392
        /// Expect a given number of logs with all topic and data checks enabled.
    2393
        function expectEmit(uint64 count) external;
    2394
    
                                                    
                                                
    2395
        /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.
    2396
        function expectEmit(address emitter, uint64 count) external;
    2397
    
                                                    
                                                
    2398
        /// Expects an error on next call that starts with the revert data.
    2399
        function expectPartialRevert(bytes4 revertData) external;
    2400
    
                                                    
                                                
    2401
        /// Expects an error on next call to reverter address, that starts with the revert data.
    2402
        function expectPartialRevert(bytes4 revertData, address reverter) external;
    2403
    
                                                    
                                                
    2404
        /// Expects an error on next call with any revert data.
    2405
        function expectRevert() external;
    2406
    
                                                    
                                                
    2407
        /// Expects an error on next call that exactly matches the revert data.
    2408
        function expectRevert(bytes4 revertData) external;
    2409
    
                                                    
                                                
    2410
        /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.
    2411
        function expectRevert(bytes4 revertData, address reverter, uint64 count) external;
    2412
    
                                                    
                                                
    2413
        /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.
    2414
        function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;
    2415
    
                                                    
                                                
    2416
        /// Expects an error on next call that exactly matches the revert data.
    2417
        function expectRevert(bytes calldata revertData) external;
    2418
    
                                                    
                                                
    2419
        /// Expects an error with any revert data on next call to reverter address.
    2420
        function expectRevert(address reverter) external;
    2421
    
                                                    
                                                
    2422
        /// Expects an error from reverter address on next call, with any revert data.
    2423
        function expectRevert(bytes4 revertData, address reverter) external;
    2424
    
                                                    
                                                
    2425
        /// Expects an error from reverter address on next call, that exactly matches the revert data.
    2426
        function expectRevert(bytes calldata revertData, address reverter) external;
    2427
    
                                                    
                                                
    2428
        /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.
    2429
        function expectRevert(uint64 count) external;
    2430
    
                                                    
                                                
    2431
        /// Expects a `count` number of reverts from the upcoming calls that match the revert data.
    2432
        function expectRevert(bytes4 revertData, uint64 count) external;
    2433
    
                                                    
                                                
    2434
        /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.
    2435
        function expectRevert(bytes calldata revertData, uint64 count) external;
    2436
    
                                                    
                                                
    2437
        /// Expects a `count` number of reverts from the upcoming calls from the reverter address.
    2438
        function expectRevert(address reverter, uint64 count) external;
    2439
    
                                                    
                                                
    2440
        /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other
    2441
        /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.
    2442
        function expectSafeMemory(uint64 min, uint64 max) external;
    2443
    
                                                    
                                                
    2444
        /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.
    2445
        /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges
    2446
        /// to the set.
    2447
        function expectSafeMemoryCall(uint64 min, uint64 max) external;
    2448
    
                                                    
                                                
    2449
        /// Marks a test as skipped. Must be called at the top level of a test.
    2450
        function skip(bool skipTest) external;
    2451
    
                                                    
                                                
    2452
        /// Marks a test as skipped with a reason. Must be called at the top level of a test.
    2453
        function skip(bool skipTest, string calldata reason) external;
    2454
    
                                                    
                                                
    2455
        /// Stops all safe memory expectation in the current subcontext.
    2456
        function stopExpectSafeMemory() external;
    2457
    
                                                    
                                                
    2458
        // ======== Utilities ========
    2459
    
                                                    
                                                
    2460
        /// Causes the next contract creation (via new) to fail and return its initcode in the returndata buffer.
    2461
        /// This allows type-safe access to the initcode payload that would be used for contract creation.
    2462
        /// Example usage:
    2463
        /// vm.interceptInitcode();
    2464
        /// bytes memory initcode;
    2465
        /// try new MyContract(param1, param2) { assert(false); }
    2466
        /// catch (bytes memory interceptedInitcode) { initcode = interceptedInitcode; }
    2467
        function interceptInitcode() external;
    2468
    }
    2469
    
                                                    
                                                
    100.0% lib/forge-std/src/console.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.4.22 <0.9.0;
    3
    
                                                    
                                                
    4
    ✓ 13
    library console {
    5
        address constant CONSOLE_ADDRESS =
    6
            0x000000000000000000636F6e736F6c652e6c6f67;
    7
    
                                                    
                                                
    8
        function _sendLogPayloadImplementation(bytes memory payload) internal view {
    9
            address consoleAddress = CONSOLE_ADDRESS;
    10
            /// @solidity memory-safe-assembly
    11
            assembly {
    12
                pop(
    13
                    staticcall(
    14
                        gas(),
    15
                        consoleAddress,
    16
                        add(payload, 32),
    17
                        mload(payload),
    18
                        0,
    19
                        0
    20
                    )
    21
                )
    22
            }
    23
        }
    24
    
                                                    
                                                
    25
        function _castToPure(
    26
          function(bytes memory) internal view fnIn
    27
        ) internal pure returns (function(bytes memory) pure fnOut) {
    28
            assembly {
    29
                fnOut := fnIn
    30
            }
    31
        }
    32
    
                                                    
                                                
    33
        function _sendLogPayload(bytes memory payload) internal pure {
    34
            _castToPure(_sendLogPayloadImplementation)(payload);
    35
        }
    36
    
                                                    
                                                
    37
        function log() internal pure {
    38
            _sendLogPayload(abi.encodeWithSignature("log()"));
    39
        }
    40
    
                                                    
                                                
    41
        function logInt(int256 p0) internal pure {
    42
            _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
    43
        }
    44
    
                                                    
                                                
    45
        function logUint(uint256 p0) internal pure {
    46
            _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    47
        }
    48
    
                                                    
                                                
    49
        function logString(string memory p0) internal pure {
    50
            _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    51
        }
    52
    
                                                    
                                                
    53
        function logBool(bool p0) internal pure {
    54
            _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    55
        }
    56
    
                                                    
                                                
    57
        function logAddress(address p0) internal pure {
    58
            _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    59
        }
    60
    
                                                    
                                                
    61
        function logBytes(bytes memory p0) internal pure {
    62
            _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
    63
        }
    64
    
                                                    
                                                
    65
        function logBytes1(bytes1 p0) internal pure {
    66
            _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
    67
        }
    68
    
                                                    
                                                
    69
        function logBytes2(bytes2 p0) internal pure {
    70
            _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
    71
        }
    72
    
                                                    
                                                
    73
        function logBytes3(bytes3 p0) internal pure {
    74
            _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
    75
        }
    76
    
                                                    
                                                
    77
        function logBytes4(bytes4 p0) internal pure {
    78
            _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
    79
        }
    80
    
                                                    
                                                
    81
        function logBytes5(bytes5 p0) internal pure {
    82
            _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
    83
        }
    84
    
                                                    
                                                
    85
        function logBytes6(bytes6 p0) internal pure {
    86
            _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
    87
        }
    88
    
                                                    
                                                
    89
        function logBytes7(bytes7 p0) internal pure {
    90
            _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
    91
        }
    92
    
                                                    
                                                
    93
        function logBytes8(bytes8 p0) internal pure {
    94
            _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
    95
        }
    96
    
                                                    
                                                
    97
        function logBytes9(bytes9 p0) internal pure {
    98
            _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
    99
        }
    100
    
                                                    
                                                
    101
        function logBytes10(bytes10 p0) internal pure {
    102
            _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
    103
        }
    104
    
                                                    
                                                
    105
        function logBytes11(bytes11 p0) internal pure {
    106
            _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
    107
        }
    108
    
                                                    
                                                
    109
        function logBytes12(bytes12 p0) internal pure {
    110
            _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
    111
        }
    112
    
                                                    
                                                
    113
        function logBytes13(bytes13 p0) internal pure {
    114
            _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
    115
        }
    116
    
                                                    
                                                
    117
        function logBytes14(bytes14 p0) internal pure {
    118
            _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
    119
        }
    120
    
                                                    
                                                
    121
        function logBytes15(bytes15 p0) internal pure {
    122
            _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
    123
        }
    124
    
                                                    
                                                
    125
        function logBytes16(bytes16 p0) internal pure {
    126
            _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
    127
        }
    128
    
                                                    
                                                
    129
        function logBytes17(bytes17 p0) internal pure {
    130
            _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
    131
        }
    132
    
                                                    
                                                
    133
        function logBytes18(bytes18 p0) internal pure {
    134
            _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
    135
        }
    136
    
                                                    
                                                
    137
        function logBytes19(bytes19 p0) internal pure {
    138
            _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
    139
        }
    140
    
                                                    
                                                
    141
        function logBytes20(bytes20 p0) internal pure {
    142
            _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
    143
        }
    144
    
                                                    
                                                
    145
        function logBytes21(bytes21 p0) internal pure {
    146
            _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
    147
        }
    148
    
                                                    
                                                
    149
        function logBytes22(bytes22 p0) internal pure {
    150
            _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
    151
        }
    152
    
                                                    
                                                
    153
        function logBytes23(bytes23 p0) internal pure {
    154
            _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
    155
        }
    156
    
                                                    
                                                
    157
        function logBytes24(bytes24 p0) internal pure {
    158
            _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
    159
        }
    160
    
                                                    
                                                
    161
        function logBytes25(bytes25 p0) internal pure {
    162
            _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
    163
        }
    164
    
                                                    
                                                
    165
        function logBytes26(bytes26 p0) internal pure {
    166
            _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
    167
        }
    168
    
                                                    
                                                
    169
        function logBytes27(bytes27 p0) internal pure {
    170
            _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
    171
        }
    172
    
                                                    
                                                
    173
        function logBytes28(bytes28 p0) internal pure {
    174
            _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
    175
        }
    176
    
                                                    
                                                
    177
        function logBytes29(bytes29 p0) internal pure {
    178
            _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
    179
        }
    180
    
                                                    
                                                
    181
        function logBytes30(bytes30 p0) internal pure {
    182
            _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
    183
        }
    184
    
                                                    
                                                
    185
        function logBytes31(bytes31 p0) internal pure {
    186
            _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
    187
        }
    188
    
                                                    
                                                
    189
        function logBytes32(bytes32 p0) internal pure {
    190
            _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
    191
        }
    192
    
                                                    
                                                
    193
        function log(uint256 p0) internal pure {
    194
            _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    195
        }
    196
    
                                                    
                                                
    197
        function log(int256 p0) internal pure {
    198
            _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
    199
        }
    200
    
                                                    
                                                
    201
        function log(string memory p0) internal pure {
    202
            _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    203
        }
    204
    
                                                    
                                                
    205
        function log(bool p0) internal pure {
    206
            _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    207
        }
    208
    
                                                    
                                                
    209
        function log(address p0) internal pure {
    210
            _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    211
        }
    212
    
                                                    
                                                
    213
        function log(uint256 p0, uint256 p1) internal pure {
    214
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
    215
        }
    216
    
                                                    
                                                
    217
        function log(uint256 p0, string memory p1) internal pure {
    218
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
    219
        }
    220
    
                                                    
                                                
    221
        function log(uint256 p0, bool p1) internal pure {
    222
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
    223
        }
    224
    
                                                    
                                                
    225
        function log(uint256 p0, address p1) internal pure {
    226
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
    227
        }
    228
    
                                                    
                                                
    229
        function log(string memory p0, uint256 p1) internal pure {
    230
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
    231
        }
    232
    
                                                    
                                                
    233
        function log(string memory p0, int256 p1) internal pure {
    234
            _sendLogPayload(abi.encodeWithSignature("log(string,int256)", p0, p1));
    235
        }
    236
    
                                                    
                                                
    237
        function log(string memory p0, string memory p1) internal pure {
    238
            _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
    239
        }
    240
    
                                                    
                                                
    241
        function log(string memory p0, bool p1) internal pure {
    242
            _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
    243
        }
    244
    
                                                    
                                                
    245
        function log(string memory p0, address p1) internal pure {
    246
            _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
    247
        }
    248
    
                                                    
                                                
    249
        function log(bool p0, uint256 p1) internal pure {
    250
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
    251
        }
    252
    
                                                    
                                                
    253
        function log(bool p0, string memory p1) internal pure {
    254
            _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
    255
        }
    256
    
                                                    
                                                
    257
        function log(bool p0, bool p1) internal pure {
    258
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
    259
        }
    260
    
                                                    
                                                
    261
        function log(bool p0, address p1) internal pure {
    262
            _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
    263
        }
    264
    
                                                    
                                                
    265
        function log(address p0, uint256 p1) internal pure {
    266
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
    267
        }
    268
    
                                                    
                                                
    269
        function log(address p0, string memory p1) internal pure {
    270
            _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
    271
        }
    272
    
                                                    
                                                
    273
        function log(address p0, bool p1) internal pure {
    274
            _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
    275
        }
    276
    
                                                    
                                                
    277
        function log(address p0, address p1) internal pure {
    278
            _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
    279
        }
    280
    
                                                    
                                                
    281
        function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
    282
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
    283
        }
    284
    
                                                    
                                                
    285
        function log(uint256 p0, uint256 p1, string memory p2) internal pure {
    286
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
    287
        }
    288
    
                                                    
                                                
    289
        function log(uint256 p0, uint256 p1, bool p2) internal pure {
    290
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
    291
        }
    292
    
                                                    
                                                
    293
        function log(uint256 p0, uint256 p1, address p2) internal pure {
    294
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
    295
        }
    296
    
                                                    
                                                
    297
        function log(uint256 p0, string memory p1, uint256 p2) internal pure {
    298
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
    299
        }
    300
    
                                                    
                                                
    301
        function log(uint256 p0, string memory p1, string memory p2) internal pure {
    302
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
    303
        }
    304
    
                                                    
                                                
    305
        function log(uint256 p0, string memory p1, bool p2) internal pure {
    306
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
    307
        }
    308
    
                                                    
                                                
    309
        function log(uint256 p0, string memory p1, address p2) internal pure {
    310
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
    311
        }
    312
    
                                                    
                                                
    313
        function log(uint256 p0, bool p1, uint256 p2) internal pure {
    314
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
    315
        }
    316
    
                                                    
                                                
    317
        function log(uint256 p0, bool p1, string memory p2) internal pure {
    318
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
    319
        }
    320
    
                                                    
                                                
    321
        function log(uint256 p0, bool p1, bool p2) internal pure {
    322
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
    323
        }
    324
    
                                                    
                                                
    325
        function log(uint256 p0, bool p1, address p2) internal pure {
    326
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
    327
        }
    328
    
                                                    
                                                
    329
        function log(uint256 p0, address p1, uint256 p2) internal pure {
    330
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
    331
        }
    332
    
                                                    
                                                
    333
        function log(uint256 p0, address p1, string memory p2) internal pure {
    334
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
    335
        }
    336
    
                                                    
                                                
    337
        function log(uint256 p0, address p1, bool p2) internal pure {
    338
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
    339
        }
    340
    
                                                    
                                                
    341
        function log(uint256 p0, address p1, address p2) internal pure {
    342
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
    343
        }
    344
    
                                                    
                                                
    345
        function log(string memory p0, uint256 p1, uint256 p2) internal pure {
    346
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
    347
        }
    348
    
                                                    
                                                
    349
        function log(string memory p0, uint256 p1, string memory p2) internal pure {
    350
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
    351
        }
    352
    
                                                    
                                                
    353
        function log(string memory p0, uint256 p1, bool p2) internal pure {
    354
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
    355
        }
    356
    
                                                    
                                                
    357
        function log(string memory p0, uint256 p1, address p2) internal pure {
    358
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
    359
        }
    360
    
                                                    
                                                
    361
        function log(string memory p0, string memory p1, uint256 p2) internal pure {
    362
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
    363
        }
    364
    
                                                    
                                                
    365
        function log(string memory p0, string memory p1, string memory p2) internal pure {
    366
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
    367
        }
    368
    
                                                    
                                                
    369
        function log(string memory p0, string memory p1, bool p2) internal pure {
    370
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
    371
        }
    372
    
                                                    
                                                
    373
        function log(string memory p0, string memory p1, address p2) internal pure {
    374
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
    375
        }
    376
    
                                                    
                                                
    377
        function log(string memory p0, bool p1, uint256 p2) internal pure {
    378
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
    379
        }
    380
    
                                                    
                                                
    381
        function log(string memory p0, bool p1, string memory p2) internal pure {
    382
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
    383
        }
    384
    
                                                    
                                                
    385
        function log(string memory p0, bool p1, bool p2) internal pure {
    386
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
    387
        }
    388
    
                                                    
                                                
    389
        function log(string memory p0, bool p1, address p2) internal pure {
    390
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
    391
        }
    392
    
                                                    
                                                
    393
        function log(string memory p0, address p1, uint256 p2) internal pure {
    394
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
    395
        }
    396
    
                                                    
                                                
    397
        function log(string memory p0, address p1, string memory p2) internal pure {
    398
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
    399
        }
    400
    
                                                    
                                                
    401
        function log(string memory p0, address p1, bool p2) internal pure {
    402
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
    403
        }
    404
    
                                                    
                                                
    405
        function log(string memory p0, address p1, address p2) internal pure {
    406
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
    407
        }
    408
    
                                                    
                                                
    409
        function log(bool p0, uint256 p1, uint256 p2) internal pure {
    410
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
    411
        }
    412
    
                                                    
                                                
    413
        function log(bool p0, uint256 p1, string memory p2) internal pure {
    414
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
    415
        }
    416
    
                                                    
                                                
    417
        function log(bool p0, uint256 p1, bool p2) internal pure {
    418
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
    419
        }
    420
    
                                                    
                                                
    421
        function log(bool p0, uint256 p1, address p2) internal pure {
    422
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
    423
        }
    424
    
                                                    
                                                
    425
        function log(bool p0, string memory p1, uint256 p2) internal pure {
    426
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
    427
        }
    428
    
                                                    
                                                
    429
        function log(bool p0, string memory p1, string memory p2) internal pure {
    430
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
    431
        }
    432
    
                                                    
                                                
    433
        function log(bool p0, string memory p1, bool p2) internal pure {
    434
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
    435
        }
    436
    
                                                    
                                                
    437
        function log(bool p0, string memory p1, address p2) internal pure {
    438
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
    439
        }
    440
    
                                                    
                                                
    441
        function log(bool p0, bool p1, uint256 p2) internal pure {
    442
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
    443
        }
    444
    
                                                    
                                                
    445
        function log(bool p0, bool p1, string memory p2) internal pure {
    446
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
    447
        }
    448
    
                                                    
                                                
    449
        function log(bool p0, bool p1, bool p2) internal pure {
    450
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
    451
        }
    452
    
                                                    
                                                
    453
        function log(bool p0, bool p1, address p2) internal pure {
    454
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
    455
        }
    456
    
                                                    
                                                
    457
        function log(bool p0, address p1, uint256 p2) internal pure {
    458
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
    459
        }
    460
    
                                                    
                                                
    461
        function log(bool p0, address p1, string memory p2) internal pure {
    462
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
    463
        }
    464
    
                                                    
                                                
    465
        function log(bool p0, address p1, bool p2) internal pure {
    466
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
    467
        }
    468
    
                                                    
                                                
    469
        function log(bool p0, address p1, address p2) internal pure {
    470
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
    471
        }
    472
    
                                                    
                                                
    473
        function log(address p0, uint256 p1, uint256 p2) internal pure {
    474
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
    475
        }
    476
    
                                                    
                                                
    477
        function log(address p0, uint256 p1, string memory p2) internal pure {
    478
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
    479
        }
    480
    
                                                    
                                                
    481
        function log(address p0, uint256 p1, bool p2) internal pure {
    482
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
    483
        }
    484
    
                                                    
                                                
    485
        function log(address p0, uint256 p1, address p2) internal pure {
    486
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
    487
        }
    488
    
                                                    
                                                
    489
        function log(address p0, string memory p1, uint256 p2) internal pure {
    490
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
    491
        }
    492
    
                                                    
                                                
    493
        function log(address p0, string memory p1, string memory p2) internal pure {
    494
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
    495
        }
    496
    
                                                    
                                                
    497
        function log(address p0, string memory p1, bool p2) internal pure {
    498
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
    499
        }
    500
    
                                                    
                                                
    501
        function log(address p0, string memory p1, address p2) internal pure {
    502
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
    503
        }
    504
    
                                                    
                                                
    505
        function log(address p0, bool p1, uint256 p2) internal pure {
    506
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
    507
        }
    508
    
                                                    
                                                
    509
        function log(address p0, bool p1, string memory p2) internal pure {
    510
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
    511
        }
    512
    
                                                    
                                                
    513
        function log(address p0, bool p1, bool p2) internal pure {
    514
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
    515
        }
    516
    
                                                    
                                                
    517
        function log(address p0, bool p1, address p2) internal pure {
    518
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
    519
        }
    520
    
                                                    
                                                
    521
        function log(address p0, address p1, uint256 p2) internal pure {
    522
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
    523
        }
    524
    
                                                    
                                                
    525
        function log(address p0, address p1, string memory p2) internal pure {
    526
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
    527
        }
    528
    
                                                    
                                                
    529
        function log(address p0, address p1, bool p2) internal pure {
    530
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
    531
        }
    532
    
                                                    
                                                
    533
        function log(address p0, address p1, address p2) internal pure {
    534
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
    535
        }
    536
    
                                                    
                                                
    537
        function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    538
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
    539
        }
    540
    
                                                    
                                                
    541
        function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    542
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
    543
        }
    544
    
                                                    
                                                
    545
        function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
    546
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
    547
        }
    548
    
                                                    
                                                
    549
        function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
    550
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
    551
        }
    552
    
                                                    
                                                
    553
        function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    554
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
    555
        }
    556
    
                                                    
                                                
    557
        function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {
    558
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
    559
        }
    560
    
                                                    
                                                
    561
        function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {
    562
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
    563
        }
    564
    
                                                    
                                                
    565
        function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {
    566
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
    567
        }
    568
    
                                                    
                                                
    569
        function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
    570
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
    571
        }
    572
    
                                                    
                                                
    573
        function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {
    574
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
    575
        }
    576
    
                                                    
                                                
    577
        function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
    578
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
    579
        }
    580
    
                                                    
                                                
    581
        function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
    582
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
    583
        }
    584
    
                                                    
                                                
    585
        function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
    586
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
    587
        }
    588
    
                                                    
                                                
    589
        function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {
    590
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
    591
        }
    592
    
                                                    
                                                
    593
        function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
    594
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
    595
        }
    596
    
                                                    
                                                
    597
        function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
    598
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
    599
        }
    600
    
                                                    
                                                
    601
        function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    602
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
    603
        }
    604
    
                                                    
                                                
    605
        function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {
    606
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
    607
        }
    608
    
                                                    
                                                
    609
        function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {
    610
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
    611
        }
    612
    
                                                    
                                                
    613
        function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {
    614
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
    615
        }
    616
    
                                                    
                                                
    617
        function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {
    618
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
    619
        }
    620
    
                                                    
                                                
    621
        function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {
    622
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
    623
        }
    624
    
                                                    
                                                
    625
        function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {
    626
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
    627
        }
    628
    
                                                    
                                                
    629
        function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {
    630
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
    631
        }
    632
    
                                                    
                                                
    633
        function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {
    634
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
    635
        }
    636
    
                                                    
                                                
    637
        function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {
    638
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
    639
        }
    640
    
                                                    
                                                
    641
        function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {
    642
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
    643
        }
    644
    
                                                    
                                                
    645
        function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {
    646
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
    647
        }
    648
    
                                                    
                                                
    649
        function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {
    650
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
    651
        }
    652
    
                                                    
                                                
    653
        function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {
    654
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
    655
        }
    656
    
                                                    
                                                
    657
        function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {
    658
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
    659
        }
    660
    
                                                    
                                                
    661
        function log(uint256 p0, string memory p1, address p2, address p3) internal pure {
    662
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
    663
        }
    664
    
                                                    
                                                
    665
        function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
    666
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
    667
        }
    668
    
                                                    
                                                
    669
        function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {
    670
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
    671
        }
    672
    
                                                    
                                                
    673
        function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
    674
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
    675
        }
    676
    
                                                    
                                                
    677
        function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
    678
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
    679
        }
    680
    
                                                    
                                                
    681
        function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {
    682
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
    683
        }
    684
    
                                                    
                                                
    685
        function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {
    686
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
    687
        }
    688
    
                                                    
                                                
    689
        function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {
    690
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
    691
        }
    692
    
                                                    
                                                
    693
        function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {
    694
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
    695
        }
    696
    
                                                    
                                                
    697
        function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
    698
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
    699
        }
    700
    
                                                    
                                                
    701
        function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {
    702
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
    703
        }
    704
    
                                                    
                                                
    705
        function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
    706
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
    707
        }
    708
    
                                                    
                                                
    709
        function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
    710
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
    711
        }
    712
    
                                                    
                                                
    713
        function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
    714
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
    715
        }
    716
    
                                                    
                                                
    717
        function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {
    718
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
    719
        }
    720
    
                                                    
                                                
    721
        function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
    722
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
    723
        }
    724
    
                                                    
                                                
    725
        function log(uint256 p0, bool p1, address p2, address p3) internal pure {
    726
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
    727
        }
    728
    
                                                    
                                                
    729
        function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
    730
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
    731
        }
    732
    
                                                    
                                                
    733
        function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {
    734
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
    735
        }
    736
    
                                                    
                                                
    737
        function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
    738
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
    739
        }
    740
    
                                                    
                                                
    741
        function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
    742
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
    743
        }
    744
    
                                                    
                                                
    745
        function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {
    746
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
    747
        }
    748
    
                                                    
                                                
    749
        function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {
    750
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
    751
        }
    752
    
                                                    
                                                
    753
        function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {
    754
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
    755
        }
    756
    
                                                    
                                                
    757
        function log(uint256 p0, address p1, string memory p2, address p3) internal pure {
    758
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
    759
        }
    760
    
                                                    
                                                
    761
        function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
    762
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
    763
        }
    764
    
                                                    
                                                
    765
        function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {
    766
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
    767
        }
    768
    
                                                    
                                                
    769
        function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
    770
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
    771
        }
    772
    
                                                    
                                                
    773
        function log(uint256 p0, address p1, bool p2, address p3) internal pure {
    774
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
    775
        }
    776
    
                                                    
                                                
    777
        function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
    778
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
    779
        }
    780
    
                                                    
                                                
    781
        function log(uint256 p0, address p1, address p2, string memory p3) internal pure {
    782
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
    783
        }
    784
    
                                                    
                                                
    785
        function log(uint256 p0, address p1, address p2, bool p3) internal pure {
    786
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
    787
        }
    788
    
                                                    
                                                
    789
        function log(uint256 p0, address p1, address p2, address p3) internal pure {
    790
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
    791
        }
    792
    
                                                    
                                                
    793
        function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    794
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
    795
        }
    796
    
                                                    
                                                
    797
        function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    798
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
    799
        }
    800
    
                                                    
                                                
    801
        function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {
    802
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
    803
        }
    804
    
                                                    
                                                
    805
        function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {
    806
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
    807
        }
    808
    
                                                    
                                                
    809
        function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    810
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
    811
        }
    812
    
                                                    
                                                
    813
        function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {
    814
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
    815
        }
    816
    
                                                    
                                                
    817
        function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {
    818
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
    819
        }
    820
    
                                                    
                                                
    821
        function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {
    822
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
    823
        }
    824
    
                                                    
                                                
    825
        function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {
    826
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
    827
        }
    828
    
                                                    
                                                
    829
        function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {
    830
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
    831
        }
    832
    
                                                    
                                                
    833
        function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {
    834
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
    835
        }
    836
    
                                                    
                                                
    837
        function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {
    838
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
    839
        }
    840
    
                                                    
                                                
    841
        function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {
    842
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
    843
        }
    844
    
                                                    
                                                
    845
        function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {
    846
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
    847
        }
    848
    
                                                    
                                                
    849
        function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {
    850
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
    851
        }
    852
    
                                                    
                                                
    853
        function log(string memory p0, uint256 p1, address p2, address p3) internal pure {
    854
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
    855
        }
    856
    
                                                    
                                                
    857
        function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    858
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
    859
        }
    860
    
                                                    
                                                
    861
        function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {
    862
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
    863
        }
    864
    
                                                    
                                                
    865
        function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {
    866
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
    867
        }
    868
    
                                                    
                                                
    869
        function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {
    870
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
    871
        }
    872
    
                                                    
                                                
    873
        function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {
    874
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
    875
        }
    876
    
                                                    
                                                
    877
        function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
    878
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
    879
        }
    880
    
                                                    
                                                
    881
        function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {
    882
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
    883
        }
    884
    
                                                    
                                                
    885
        function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {
    886
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
    887
        }
    888
    
                                                    
                                                
    889
        function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {
    890
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
    891
        }
    892
    
                                                    
                                                
    893
        function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
    894
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
    895
        }
    896
    
                                                    
                                                
    897
        function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {
    898
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
    899
        }
    900
    
                                                    
                                                
    901
        function log(string memory p0, string memory p1, bool p2, address p3) internal pure {
    902
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
    903
        }
    904
    
                                                    
                                                
    905
        function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {
    906
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
    907
        }
    908
    
                                                    
                                                
    909
        function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
    910
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
    911
        }
    912
    
                                                    
                                                
    913
        function log(string memory p0, string memory p1, address p2, bool p3) internal pure {
    914
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
    915
        }
    916
    
                                                    
                                                
    917
        function log(string memory p0, string memory p1, address p2, address p3) internal pure {
    918
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
    919
        }
    920
    
                                                    
                                                
    921
        function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {
    922
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
    923
        }
    924
    
                                                    
                                                
    925
        function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {
    926
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
    927
        }
    928
    
                                                    
                                                
    929
        function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {
    930
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
    931
        }
    932
    
                                                    
                                                
    933
        function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {
    934
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
    935
        }
    936
    
                                                    
                                                
    937
        function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {
    938
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
    939
        }
    940
    
                                                    
                                                
    941
        function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
    942
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
    943
        }
    944
    
                                                    
                                                
    945
        function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {
    946
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
    947
        }
    948
    
                                                    
                                                
    949
        function log(string memory p0, bool p1, string memory p2, address p3) internal pure {
    950
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
    951
        }
    952
    
                                                    
                                                
    953
        function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {
    954
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
    955
        }
    956
    
                                                    
                                                
    957
        function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {
    958
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
    959
        }
    960
    
                                                    
                                                
    961
        function log(string memory p0, bool p1, bool p2, bool p3) internal pure {
    962
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
    963
        }
    964
    
                                                    
                                                
    965
        function log(string memory p0, bool p1, bool p2, address p3) internal pure {
    966
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
    967
        }
    968
    
                                                    
                                                
    969
        function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {
    970
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
    971
        }
    972
    
                                                    
                                                
    973
        function log(string memory p0, bool p1, address p2, string memory p3) internal pure {
    974
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
    975
        }
    976
    
                                                    
                                                
    977
        function log(string memory p0, bool p1, address p2, bool p3) internal pure {
    978
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
    979
        }
    980
    
                                                    
                                                
    981
        function log(string memory p0, bool p1, address p2, address p3) internal pure {
    982
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
    983
        }
    984
    
                                                    
                                                
    985
        function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {
    986
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
    987
        }
    988
    
                                                    
                                                
    989
        function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {
    990
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
    991
        }
    992
    
                                                    
                                                
    993
        function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {
    994
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
    995
        }
    996
    
                                                    
                                                
    997
        function log(string memory p0, address p1, uint256 p2, address p3) internal pure {
    998
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
    999
        }
    1000
    
                                                    
                                                
    1001
        function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {
    1002
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
    1003
        }
    1004
    
                                                    
                                                
    1005
        function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
    1006
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
    1007
        }
    1008
    
                                                    
                                                
    1009
        function log(string memory p0, address p1, string memory p2, bool p3) internal pure {
    1010
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
    1011
        }
    1012
    
                                                    
                                                
    1013
        function log(string memory p0, address p1, string memory p2, address p3) internal pure {
    1014
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
    1015
        }
    1016
    
                                                    
                                                
    1017
        function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {
    1018
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
    1019
        }
    1020
    
                                                    
                                                
    1021
        function log(string memory p0, address p1, bool p2, string memory p3) internal pure {
    1022
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
    1023
        }
    1024
    
                                                    
                                                
    1025
        function log(string memory p0, address p1, bool p2, bool p3) internal pure {
    1026
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
    1027
        }
    1028
    
                                                    
                                                
    1029
        function log(string memory p0, address p1, bool p2, address p3) internal pure {
    1030
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
    1031
        }
    1032
    
                                                    
                                                
    1033
        function log(string memory p0, address p1, address p2, uint256 p3) internal pure {
    1034
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
    1035
        }
    1036
    
                                                    
                                                
    1037
        function log(string memory p0, address p1, address p2, string memory p3) internal pure {
    1038
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
    1039
        }
    1040
    
                                                    
                                                
    1041
        function log(string memory p0, address p1, address p2, bool p3) internal pure {
    1042
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
    1043
        }
    1044
    
                                                    
                                                
    1045
        function log(string memory p0, address p1, address p2, address p3) internal pure {
    1046
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
    1047
        }
    1048
    
                                                    
                                                
    1049
        function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    1050
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
    1051
        }
    1052
    
                                                    
                                                
    1053
        function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    1054
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
    1055
        }
    1056
    
                                                    
                                                
    1057
        function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
    1058
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
    1059
        }
    1060
    
                                                    
                                                
    1061
        function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
    1062
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
    1063
        }
    1064
    
                                                    
                                                
    1065
        function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    1066
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
    1067
        }
    1068
    
                                                    
                                                
    1069
        function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {
    1070
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
    1071
        }
    1072
    
                                                    
                                                
    1073
        function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {
    1074
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
    1075
        }
    1076
    
                                                    
                                                
    1077
        function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {
    1078
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
    1079
        }
    1080
    
                                                    
                                                
    1081
        function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
    1082
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
    1083
        }
    1084
    
                                                    
                                                
    1085
        function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {
    1086
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
    1087
        }
    1088
    
                                                    
                                                
    1089
        function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
    1090
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
    1091
        }
    1092
    
                                                    
                                                
    1093
        function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
    1094
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
    1095
        }
    1096
    
                                                    
                                                
    1097
        function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
    1098
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
    1099
        }
    1100
    
                                                    
                                                
    1101
        function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {
    1102
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
    1103
        }
    1104
    
                                                    
                                                
    1105
        function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
    1106
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
    1107
        }
    1108
    
                                                    
                                                
    1109
        function log(bool p0, uint256 p1, address p2, address p3) internal pure {
    1110
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
    1111
        }
    1112
    
                                                    
                                                
    1113
        function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    1114
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
    1115
        }
    1116
    
                                                    
                                                
    1117
        function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {
    1118
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
    1119
        }
    1120
    
                                                    
                                                
    1121
        function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {
    1122
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
    1123
        }
    1124
    
                                                    
                                                
    1125
        function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {
    1126
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
    1127
        }
    1128
    
                                                    
                                                
    1129
        function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {
    1130
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
    1131
        }
    1132
    
                                                    
                                                
    1133
        function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
    1134
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
    1135
        }
    1136
    
                                                    
                                                
    1137
        function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {
    1138
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
    1139
        }
    1140
    
                                                    
                                                
    1141
        function log(bool p0, string memory p1, string memory p2, address p3) internal pure {
    1142
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
    1143
        }
    1144
    
                                                    
                                                
    1145
        function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {
    1146
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
    1147
        }
    1148
    
                                                    
                                                
    1149
        function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {
    1150
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
    1151
        }
    1152
    
                                                    
                                                
    1153
        function log(bool p0, string memory p1, bool p2, bool p3) internal pure {
    1154
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
    1155
        }
    1156
    
                                                    
                                                
    1157
        function log(bool p0, string memory p1, bool p2, address p3) internal pure {
    1158
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
    1159
        }
    1160
    
                                                    
                                                
    1161
        function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {
    1162
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
    1163
        }
    1164
    
                                                    
                                                
    1165
        function log(bool p0, string memory p1, address p2, string memory p3) internal pure {
    1166
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
    1167
        }
    1168
    
                                                    
                                                
    1169
        function log(bool p0, string memory p1, address p2, bool p3) internal pure {
    1170
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
    1171
        }
    1172
    
                                                    
                                                
    1173
        function log(bool p0, string memory p1, address p2, address p3) internal pure {
    1174
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
    1175
        }
    1176
    
                                                    
                                                
    1177
        function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
    1178
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
    1179
        }
    1180
    
                                                    
                                                
    1181
        function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {
    1182
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
    1183
        }
    1184
    
                                                    
                                                
    1185
        function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
    1186
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
    1187
        }
    1188
    
                                                    
                                                
    1189
        function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
    1190
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
    1191
        }
    1192
    
                                                    
                                                
    1193
        function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {
    1194
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
    1195
        }
    1196
    
                                                    
                                                
    1197
        function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {
    1198
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
    1199
        }
    1200
    
                                                    
                                                
    1201
        function log(bool p0, bool p1, string memory p2, bool p3) internal pure {
    1202
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
    1203
        }
    1204
    
                                                    
                                                
    1205
        function log(bool p0, bool p1, string memory p2, address p3) internal pure {
    1206
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
    1207
        }
    1208
    
                                                    
                                                
    1209
        function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
    1210
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
    1211
        }
    1212
    
                                                    
                                                
    1213
        function log(bool p0, bool p1, bool p2, string memory p3) internal pure {
    1214
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
    1215
        }
    1216
    
                                                    
                                                
    1217
        function log(bool p0, bool p1, bool p2, bool p3) internal pure {
    1218
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
    1219
        }
    1220
    
                                                    
                                                
    1221
        function log(bool p0, bool p1, bool p2, address p3) internal pure {
    1222
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
    1223
        }
    1224
    
                                                    
                                                
    1225
        function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
    1226
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
    1227
        }
    1228
    
                                                    
                                                
    1229
        function log(bool p0, bool p1, address p2, string memory p3) internal pure {
    1230
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
    1231
        }
    1232
    
                                                    
                                                
    1233
        function log(bool p0, bool p1, address p2, bool p3) internal pure {
    1234
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
    1235
        }
    1236
    
                                                    
                                                
    1237
        function log(bool p0, bool p1, address p2, address p3) internal pure {
    1238
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
    1239
        }
    1240
    
                                                    
                                                
    1241
        function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
    1242
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
    1243
        }
    1244
    
                                                    
                                                
    1245
        function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {
    1246
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
    1247
        }
    1248
    
                                                    
                                                
    1249
        function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
    1250
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
    1251
        }
    1252
    
                                                    
                                                
    1253
        function log(bool p0, address p1, uint256 p2, address p3) internal pure {
    1254
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
    1255
        }
    1256
    
                                                    
                                                
    1257
        function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {
    1258
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
    1259
        }
    1260
    
                                                    
                                                
    1261
        function log(bool p0, address p1, string memory p2, string memory p3) internal pure {
    1262
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
    1263
        }
    1264
    
                                                    
                                                
    1265
        function log(bool p0, address p1, string memory p2, bool p3) internal pure {
    1266
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
    1267
        }
    1268
    
                                                    
                                                
    1269
        function log(bool p0, address p1, string memory p2, address p3) internal pure {
    1270
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
    1271
        }
    1272
    
                                                    
                                                
    1273
        function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
    1274
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
    1275
        }
    1276
    
                                                    
                                                
    1277
        function log(bool p0, address p1, bool p2, string memory p3) internal pure {
    1278
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
    1279
        }
    1280
    
                                                    
                                                
    1281
        function log(bool p0, address p1, bool p2, bool p3) internal pure {
    1282
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
    1283
        }
    1284
    
                                                    
                                                
    1285
        function log(bool p0, address p1, bool p2, address p3) internal pure {
    1286
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
    1287
        }
    1288
    
                                                    
                                                
    1289
        function log(bool p0, address p1, address p2, uint256 p3) internal pure {
    1290
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
    1291
        }
    1292
    
                                                    
                                                
    1293
        function log(bool p0, address p1, address p2, string memory p3) internal pure {
    1294
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
    1295
        }
    1296
    
                                                    
                                                
    1297
        function log(bool p0, address p1, address p2, bool p3) internal pure {
    1298
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
    1299
        }
    1300
    
                                                    
                                                
    1301
        function log(bool p0, address p1, address p2, address p3) internal pure {
    1302
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
    1303
        }
    1304
    
                                                    
                                                
    1305
        function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    1306
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
    1307
        }
    1308
    
                                                    
                                                
    1309
        function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    1310
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
    1311
        }
    1312
    
                                                    
                                                
    1313
        function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
    1314
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
    1315
        }
    1316
    
                                                    
                                                
    1317
        function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
    1318
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
    1319
        }
    1320
    
                                                    
                                                
    1321
        function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    1322
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
    1323
        }
    1324
    
                                                    
                                                
    1325
        function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {
    1326
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
    1327
        }
    1328
    
                                                    
                                                
    1329
        function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {
    1330
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
    1331
        }
    1332
    
                                                    
                                                
    1333
        function log(address p0, uint256 p1, string memory p2, address p3) internal pure {
    1334
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
    1335
        }
    1336
    
                                                    
                                                
    1337
        function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
    1338
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
    1339
        }
    1340
    
                                                    
                                                
    1341
        function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {
    1342
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
    1343
        }
    1344
    
                                                    
                                                
    1345
        function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
    1346
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
    1347
        }
    1348
    
                                                    
                                                
    1349
        function log(address p0, uint256 p1, bool p2, address p3) internal pure {
    1350
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
    1351
        }
    1352
    
                                                    
                                                
    1353
        function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
    1354
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
    1355
        }
    1356
    
                                                    
                                                
    1357
        function log(address p0, uint256 p1, address p2, string memory p3) internal pure {
    1358
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
    1359
        }
    1360
    
                                                    
                                                
    1361
        function log(address p0, uint256 p1, address p2, bool p3) internal pure {
    1362
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
    1363
        }
    1364
    
                                                    
                                                
    1365
        function log(address p0, uint256 p1, address p2, address p3) internal pure {
    1366
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
    1367
        }
    1368
    
                                                    
                                                
    1369
        function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    1370
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
    1371
        }
    1372
    
                                                    
                                                
    1373
        function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {
    1374
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
    1375
        }
    1376
    
                                                    
                                                
    1377
        function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {
    1378
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
    1379
        }
    1380
    
                                                    
                                                
    1381
        function log(address p0, string memory p1, uint256 p2, address p3) internal pure {
    1382
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
    1383
        }
    1384
    
                                                    
                                                
    1385
        function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {
    1386
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
    1387
        }
    1388
    
                                                    
                                                
    1389
        function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
    1390
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
    1391
        }
    1392
    
                                                    
                                                
    1393
        function log(address p0, string memory p1, string memory p2, bool p3) internal pure {
    1394
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
    1395
        }
    1396
    
                                                    
                                                
    1397
        function log(address p0, string memory p1, string memory p2, address p3) internal pure {
    1398
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
    1399
        }
    1400
    
                                                    
                                                
    1401
        function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {
    1402
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
    1403
        }
    1404
    
                                                    
                                                
    1405
        function log(address p0, string memory p1, bool p2, string memory p3) internal pure {
    1406
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
    1407
        }
    1408
    
                                                    
                                                
    1409
        function log(address p0, string memory p1, bool p2, bool p3) internal pure {
    1410
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
    1411
        }
    1412
    
                                                    
                                                
    1413
        function log(address p0, string memory p1, bool p2, address p3) internal pure {
    1414
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
    1415
        }
    1416
    
                                                    
                                                
    1417
        function log(address p0, string memory p1, address p2, uint256 p3) internal pure {
    1418
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
    1419
        }
    1420
    
                                                    
                                                
    1421
        function log(address p0, string memory p1, address p2, string memory p3) internal pure {
    1422
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
    1423
        }
    1424
    
                                                    
                                                
    1425
        function log(address p0, string memory p1, address p2, bool p3) internal pure {
    1426
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
    1427
        }
    1428
    
                                                    
                                                
    1429
        function log(address p0, string memory p1, address p2, address p3) internal pure {
    1430
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
    1431
        }
    1432
    
                                                    
                                                
    1433
        function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
    1434
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
    1435
        }
    1436
    
                                                    
                                                
    1437
        function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {
    1438
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
    1439
        }
    1440
    
                                                    
                                                
    1441
        function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
    1442
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
    1443
        }
    1444
    
                                                    
                                                
    1445
        function log(address p0, bool p1, uint256 p2, address p3) internal pure {
    1446
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
    1447
        }
    1448
    
                                                    
                                                
    1449
        function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {
    1450
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
    1451
        }
    1452
    
                                                    
                                                
    1453
        function log(address p0, bool p1, string memory p2, string memory p3) internal pure {
    1454
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
    1455
        }
    1456
    
                                                    
                                                
    1457
        function log(address p0, bool p1, string memory p2, bool p3) internal pure {
    1458
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
    1459
        }
    1460
    
                                                    
                                                
    1461
        function log(address p0, bool p1, string memory p2, address p3) internal pure {
    1462
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
    1463
        }
    1464
    
                                                    
                                                
    1465
        function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
    1466
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
    1467
        }
    1468
    
                                                    
                                                
    1469
        function log(address p0, bool p1, bool p2, string memory p3) internal pure {
    1470
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
    1471
        }
    1472
    
                                                    
                                                
    1473
        function log(address p0, bool p1, bool p2, bool p3) internal pure {
    1474
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
    1475
        }
    1476
    
                                                    
                                                
    1477
        function log(address p0, bool p1, bool p2, address p3) internal pure {
    1478
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
    1479
        }
    1480
    
                                                    
                                                
    1481
        function log(address p0, bool p1, address p2, uint256 p3) internal pure {
    1482
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
    1483
        }
    1484
    
                                                    
                                                
    1485
        function log(address p0, bool p1, address p2, string memory p3) internal pure {
    1486
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
    1487
        }
    1488
    
                                                    
                                                
    1489
        function log(address p0, bool p1, address p2, bool p3) internal pure {
    1490
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
    1491
        }
    1492
    
                                                    
                                                
    1493
        function log(address p0, bool p1, address p2, address p3) internal pure {
    1494
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
    1495
        }
    1496
    
                                                    
                                                
    1497
        function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
    1498
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
    1499
        }
    1500
    
                                                    
                                                
    1501
        function log(address p0, address p1, uint256 p2, string memory p3) internal pure {
    1502
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
    1503
        }
    1504
    
                                                    
                                                
    1505
        function log(address p0, address p1, uint256 p2, bool p3) internal pure {
    1506
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
    1507
        }
    1508
    
                                                    
                                                
    1509
        function log(address p0, address p1, uint256 p2, address p3) internal pure {
    1510
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
    1511
        }
    1512
    
                                                    
                                                
    1513
        function log(address p0, address p1, string memory p2, uint256 p3) internal pure {
    1514
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
    1515
        }
    1516
    
                                                    
                                                
    1517
        function log(address p0, address p1, string memory p2, string memory p3) internal pure {
    1518
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
    1519
        }
    1520
    
                                                    
                                                
    1521
        function log(address p0, address p1, string memory p2, bool p3) internal pure {
    1522
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
    1523
        }
    1524
    
                                                    
                                                
    1525
        function log(address p0, address p1, string memory p2, address p3) internal pure {
    1526
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
    1527
        }
    1528
    
                                                    
                                                
    1529
        function log(address p0, address p1, bool p2, uint256 p3) internal pure {
    1530
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
    1531
        }
    1532
    
                                                    
                                                
    1533
        function log(address p0, address p1, bool p2, string memory p3) internal pure {
    1534
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
    1535
        }
    1536
    
                                                    
                                                
    1537
        function log(address p0, address p1, bool p2, bool p3) internal pure {
    1538
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
    1539
        }
    1540
    
                                                    
                                                
    1541
        function log(address p0, address p1, bool p2, address p3) internal pure {
    1542
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
    1543
        }
    1544
    
                                                    
                                                
    1545
        function log(address p0, address p1, address p2, uint256 p3) internal pure {
    1546
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
    1547
        }
    1548
    
                                                    
                                                
    1549
        function log(address p0, address p1, address p2, string memory p3) internal pure {
    1550
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
    1551
        }
    1552
    
                                                    
                                                
    1553
        function log(address p0, address p1, address p2, bool p3) internal pure {
    1554
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
    1555
        }
    1556
    
                                                    
                                                
    1557
        function log(address p0, address p1, address p2, address p3) internal pure {
    1558
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
    1559
        }
    1560
    }
    1561
    
                                                    
                                                
    0.0% lib/forge-std/src/console2.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.4.22 <0.9.0;
    3
    
                                                    
                                                
    4
    import {console as console2} from "./console.sol";
    5
    
                                                    
                                                
    0.0% lib/forge-std/src/interfaces/IMulticall3.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    interface IMulticall3 {
    7
        struct Call {
    8
            address target;
    9
            bytes callData;
    10
        }
    11
    
                                                    
                                                
    12
        struct Call3 {
    13
            address target;
    14
            bool allowFailure;
    15
            bytes callData;
    16
        }
    17
    
                                                    
                                                
    18
        struct Call3Value {
    19
            address target;
    20
            bool allowFailure;
    21
            uint256 value;
    22
            bytes callData;
    23
        }
    24
    
                                                    
                                                
    25
        struct Result {
    26
            bool success;
    27
            bytes returnData;
    28
        }
    29
    
                                                    
                                                
    30
        function aggregate(Call[] calldata calls)
    31
            external
    32
            payable
    33
            returns (uint256 blockNumber, bytes[] memory returnData);
    34
    
                                                    
                                                
    35
        function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);
    36
    
                                                    
                                                
    37
        function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);
    38
    
                                                    
                                                
    39
        function blockAndAggregate(Call[] calldata calls)
    40
            external
    41
            payable
    42
            returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
    43
    
                                                    
                                                
    44
        function getBasefee() external view returns (uint256 basefee);
    45
    
                                                    
                                                
    46
        function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);
    47
    
                                                    
                                                
    48
        function getBlockNumber() external view returns (uint256 blockNumber);
    49
    
                                                    
                                                
    50
        function getChainId() external view returns (uint256 chainid);
    51
    
                                                    
                                                
    52
        function getCurrentBlockCoinbase() external view returns (address coinbase);
    53
    
                                                    
                                                
    54
        function getCurrentBlockDifficulty() external view returns (uint256 difficulty);
    55
    
                                                    
                                                
    56
        function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);
    57
    
                                                    
                                                
    58
        function getCurrentBlockTimestamp() external view returns (uint256 timestamp);
    59
    
                                                    
                                                
    60
        function getEthBalance(address addr) external view returns (uint256 balance);
    61
    
                                                    
                                                
    62
        function getLastBlockHash() external view returns (bytes32 blockHash);
    63
    
                                                    
                                                
    64
        function tryAggregate(bool requireSuccess, Call[] calldata calls)
    65
            external
    66
            payable
    67
            returns (Result[] memory returnData);
    68
    
                                                    
                                                
    69
        function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)
    70
            external
    71
            payable
    72
            returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
    73
    }
    74
    
                                                    
                                                
    100.0% lib/forge-std/src/safeconsole.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    /// @author philogy <https://github.com/philogy>
    5
    /// @dev Code generated automatically by script.
    6
    ✓ 13
    library safeconsole {
    7
        uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;
    8
    
                                                    
                                                
    9
        // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)
    10
        // for the view-to-pure log trick.
    11
        function _sendLogPayload(uint256 offset, uint256 size) private pure {
    12
            function(uint256, uint256) internal view fnIn = _sendLogPayloadView;
    13
            function(uint256, uint256) internal pure pureSendLogPayload;
    14
            /// @solidity memory-safe-assembly
    15
            assembly {
    16
                pureSendLogPayload := fnIn
    17
            }
    18
            pureSendLogPayload(offset, size);
    19
        }
    20
    
                                                    
                                                
    21
        function _sendLogPayloadView(uint256 offset, uint256 size) private view {
    22
            /// @solidity memory-safe-assembly
    23
            assembly {
    24
                pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))
    25
            }
    26
        }
    27
    
                                                    
                                                
    28
        function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {
    29
            function(uint256, uint256, uint256) internal view fnIn = _memcopyView;
    30
            function(uint256, uint256, uint256) internal pure pureMemcopy;
    31
            /// @solidity memory-safe-assembly
    32
            assembly {
    33
                pureMemcopy := fnIn
    34
            }
    35
            pureMemcopy(fromOffset, toOffset, length);
    36
        }
    37
    
                                                    
                                                
    38
        function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {
    39
            /// @solidity memory-safe-assembly
    40
            assembly {
    41
                pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))
    42
            }
    43
        }
    44
    
                                                    
                                                
    45
        function logMemory(uint256 offset, uint256 length) internal pure {
    46
            if (offset >= 0x60) {
    47
                // Sufficient memory before slice to prepare call header.
    48
                bytes32 m0;
    49
                bytes32 m1;
    50
                bytes32 m2;
    51
                /// @solidity memory-safe-assembly
    52
                assembly {
    53
                    m0 := mload(sub(offset, 0x60))
    54
                    m1 := mload(sub(offset, 0x40))
    55
                    m2 := mload(sub(offset, 0x20))
    56
                    // Selector of `log(bytes)`.
    57
                    mstore(sub(offset, 0x60), 0x0be77f56)
    58
                    mstore(sub(offset, 0x40), 0x20)
    59
                    mstore(sub(offset, 0x20), length)
    60
                }
    61
                _sendLogPayload(offset - 0x44, length + 0x44);
    62
                /// @solidity memory-safe-assembly
    63
                assembly {
    64
                    mstore(sub(offset, 0x60), m0)
    65
                    mstore(sub(offset, 0x40), m1)
    66
                    mstore(sub(offset, 0x20), m2)
    67
                }
    68
            } else {
    69
                // Insufficient space, so copy slice forward, add header and reverse.
    70
                bytes32 m0;
    71
                bytes32 m1;
    72
                bytes32 m2;
    73
                uint256 endOffset = offset + length;
    74
                /// @solidity memory-safe-assembly
    75
                assembly {
    76
                    m0 := mload(add(endOffset, 0x00))
    77
                    m1 := mload(add(endOffset, 0x20))
    78
                    m2 := mload(add(endOffset, 0x40))
    79
                }
    80
                _memcopy(offset, offset + 0x60, length);
    81
                /// @solidity memory-safe-assembly
    82
                assembly {
    83
                    // Selector of `log(bytes)`.
    84
                    mstore(add(offset, 0x00), 0x0be77f56)
    85
                    mstore(add(offset, 0x20), 0x20)
    86
                    mstore(add(offset, 0x40), length)
    87
                }
    88
                _sendLogPayload(offset + 0x1c, length + 0x44);
    89
                _memcopy(offset + 0x60, offset, length);
    90
                /// @solidity memory-safe-assembly
    91
                assembly {
    92
                    mstore(add(endOffset, 0x00), m0)
    93
                    mstore(add(endOffset, 0x20), m1)
    94
                    mstore(add(endOffset, 0x40), m2)
    95
                }
    96
            }
    97
        }
    98
    
                                                    
                                                
    99
        function log(address p0) internal pure {
    100
            bytes32 m0;
    101
            bytes32 m1;
    102
            /// @solidity memory-safe-assembly
    103
            assembly {
    104
                m0 := mload(0x00)
    105
                m1 := mload(0x20)
    106
                // Selector of `log(address)`.
    107
                mstore(0x00, 0x2c2ecbc2)
    108
                mstore(0x20, p0)
    109
            }
    110
            _sendLogPayload(0x1c, 0x24);
    111
            /// @solidity memory-safe-assembly
    112
            assembly {
    113
                mstore(0x00, m0)
    114
                mstore(0x20, m1)
    115
            }
    116
        }
    117
    
                                                    
                                                
    118
        function log(bool p0) internal pure {
    119
            bytes32 m0;
    120
            bytes32 m1;
    121
            /// @solidity memory-safe-assembly
    122
            assembly {
    123
                m0 := mload(0x00)
    124
                m1 := mload(0x20)
    125
                // Selector of `log(bool)`.
    126
                mstore(0x00, 0x32458eed)
    127
                mstore(0x20, p0)
    128
            }
    129
            _sendLogPayload(0x1c, 0x24);
    130
            /// @solidity memory-safe-assembly
    131
            assembly {
    132
                mstore(0x00, m0)
    133
                mstore(0x20, m1)
    134
            }
    135
        }
    136
    
                                                    
                                                
    137
        function log(uint256 p0) internal pure {
    138
            bytes32 m0;
    139
            bytes32 m1;
    140
            /// @solidity memory-safe-assembly
    141
            assembly {
    142
                m0 := mload(0x00)
    143
                m1 := mload(0x20)
    144
                // Selector of `log(uint256)`.
    145
                mstore(0x00, 0xf82c50f1)
    146
                mstore(0x20, p0)
    147
            }
    148
            _sendLogPayload(0x1c, 0x24);
    149
            /// @solidity memory-safe-assembly
    150
            assembly {
    151
                mstore(0x00, m0)
    152
                mstore(0x20, m1)
    153
            }
    154
        }
    155
    
                                                    
                                                
    156
        function log(bytes32 p0) internal pure {
    157
            bytes32 m0;
    158
            bytes32 m1;
    159
            bytes32 m2;
    160
            bytes32 m3;
    161
            /// @solidity memory-safe-assembly
    162
            assembly {
    163
                function writeString(pos, w) {
    164
                    let length := 0
    165
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    166
                    mstore(pos, length)
    167
                    let shift := sub(256, shl(3, length))
    168
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    169
                }
    170
                m0 := mload(0x00)
    171
                m1 := mload(0x20)
    172
                m2 := mload(0x40)
    173
                m3 := mload(0x60)
    174
                // Selector of `log(string)`.
    175
                mstore(0x00, 0x41304fac)
    176
                mstore(0x20, 0x20)
    177
                writeString(0x40, p0)
    178
            }
    179
            _sendLogPayload(0x1c, 0x64);
    180
            /// @solidity memory-safe-assembly
    181
            assembly {
    182
                mstore(0x00, m0)
    183
                mstore(0x20, m1)
    184
                mstore(0x40, m2)
    185
                mstore(0x60, m3)
    186
            }
    187
        }
    188
    
                                                    
                                                
    189
        function log(address p0, address p1) internal pure {
    190
            bytes32 m0;
    191
            bytes32 m1;
    192
            bytes32 m2;
    193
            /// @solidity memory-safe-assembly
    194
            assembly {
    195
                m0 := mload(0x00)
    196
                m1 := mload(0x20)
    197
                m2 := mload(0x40)
    198
                // Selector of `log(address,address)`.
    199
                mstore(0x00, 0xdaf0d4aa)
    200
                mstore(0x20, p0)
    201
                mstore(0x40, p1)
    202
            }
    203
            _sendLogPayload(0x1c, 0x44);
    204
            /// @solidity memory-safe-assembly
    205
            assembly {
    206
                mstore(0x00, m0)
    207
                mstore(0x20, m1)
    208
                mstore(0x40, m2)
    209
            }
    210
        }
    211
    
                                                    
                                                
    212
        function log(address p0, bool p1) internal pure {
    213
            bytes32 m0;
    214
            bytes32 m1;
    215
            bytes32 m2;
    216
            /// @solidity memory-safe-assembly
    217
            assembly {
    218
                m0 := mload(0x00)
    219
                m1 := mload(0x20)
    220
                m2 := mload(0x40)
    221
                // Selector of `log(address,bool)`.
    222
                mstore(0x00, 0x75b605d3)
    223
                mstore(0x20, p0)
    224
                mstore(0x40, p1)
    225
            }
    226
            _sendLogPayload(0x1c, 0x44);
    227
            /// @solidity memory-safe-assembly
    228
            assembly {
    229
                mstore(0x00, m0)
    230
                mstore(0x20, m1)
    231
                mstore(0x40, m2)
    232
            }
    233
        }
    234
    
                                                    
                                                
    235
        function log(address p0, uint256 p1) internal pure {
    236
            bytes32 m0;
    237
            bytes32 m1;
    238
            bytes32 m2;
    239
            /// @solidity memory-safe-assembly
    240
            assembly {
    241
                m0 := mload(0x00)
    242
                m1 := mload(0x20)
    243
                m2 := mload(0x40)
    244
                // Selector of `log(address,uint256)`.
    245
                mstore(0x00, 0x8309e8a8)
    246
                mstore(0x20, p0)
    247
                mstore(0x40, p1)
    248
            }
    249
            _sendLogPayload(0x1c, 0x44);
    250
            /// @solidity memory-safe-assembly
    251
            assembly {
    252
                mstore(0x00, m0)
    253
                mstore(0x20, m1)
    254
                mstore(0x40, m2)
    255
            }
    256
        }
    257
    
                                                    
                                                
    258
        function log(address p0, bytes32 p1) internal pure {
    259
            bytes32 m0;
    260
            bytes32 m1;
    261
            bytes32 m2;
    262
            bytes32 m3;
    263
            bytes32 m4;
    264
            /// @solidity memory-safe-assembly
    265
            assembly {
    266
                function writeString(pos, w) {
    267
                    let length := 0
    268
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    269
                    mstore(pos, length)
    270
                    let shift := sub(256, shl(3, length))
    271
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    272
                }
    273
                m0 := mload(0x00)
    274
                m1 := mload(0x20)
    275
                m2 := mload(0x40)
    276
                m3 := mload(0x60)
    277
                m4 := mload(0x80)
    278
                // Selector of `log(address,string)`.
    279
                mstore(0x00, 0x759f86bb)
    280
                mstore(0x20, p0)
    281
                mstore(0x40, 0x40)
    282
                writeString(0x60, p1)
    283
            }
    284
            _sendLogPayload(0x1c, 0x84);
    285
            /// @solidity memory-safe-assembly
    286
            assembly {
    287
                mstore(0x00, m0)
    288
                mstore(0x20, m1)
    289
                mstore(0x40, m2)
    290
                mstore(0x60, m3)
    291
                mstore(0x80, m4)
    292
            }
    293
        }
    294
    
                                                    
                                                
    295
        function log(bool p0, address p1) internal pure {
    296
            bytes32 m0;
    297
            bytes32 m1;
    298
            bytes32 m2;
    299
            /// @solidity memory-safe-assembly
    300
            assembly {
    301
                m0 := mload(0x00)
    302
                m1 := mload(0x20)
    303
                m2 := mload(0x40)
    304
                // Selector of `log(bool,address)`.
    305
                mstore(0x00, 0x853c4849)
    306
                mstore(0x20, p0)
    307
                mstore(0x40, p1)
    308
            }
    309
            _sendLogPayload(0x1c, 0x44);
    310
            /// @solidity memory-safe-assembly
    311
            assembly {
    312
                mstore(0x00, m0)
    313
                mstore(0x20, m1)
    314
                mstore(0x40, m2)
    315
            }
    316
        }
    317
    
                                                    
                                                
    318
        function log(bool p0, bool p1) internal pure {
    319
            bytes32 m0;
    320
            bytes32 m1;
    321
            bytes32 m2;
    322
            /// @solidity memory-safe-assembly
    323
            assembly {
    324
                m0 := mload(0x00)
    325
                m1 := mload(0x20)
    326
                m2 := mload(0x40)
    327
                // Selector of `log(bool,bool)`.
    328
                mstore(0x00, 0x2a110e83)
    329
                mstore(0x20, p0)
    330
                mstore(0x40, p1)
    331
            }
    332
            _sendLogPayload(0x1c, 0x44);
    333
            /// @solidity memory-safe-assembly
    334
            assembly {
    335
                mstore(0x00, m0)
    336
                mstore(0x20, m1)
    337
                mstore(0x40, m2)
    338
            }
    339
        }
    340
    
                                                    
                                                
    341
        function log(bool p0, uint256 p1) internal pure {
    342
            bytes32 m0;
    343
            bytes32 m1;
    344
            bytes32 m2;
    345
            /// @solidity memory-safe-assembly
    346
            assembly {
    347
                m0 := mload(0x00)
    348
                m1 := mload(0x20)
    349
                m2 := mload(0x40)
    350
                // Selector of `log(bool,uint256)`.
    351
                mstore(0x00, 0x399174d3)
    352
                mstore(0x20, p0)
    353
                mstore(0x40, p1)
    354
            }
    355
            _sendLogPayload(0x1c, 0x44);
    356
            /// @solidity memory-safe-assembly
    357
            assembly {
    358
                mstore(0x00, m0)
    359
                mstore(0x20, m1)
    360
                mstore(0x40, m2)
    361
            }
    362
        }
    363
    
                                                    
                                                
    364
        function log(bool p0, bytes32 p1) internal pure {
    365
            bytes32 m0;
    366
            bytes32 m1;
    367
            bytes32 m2;
    368
            bytes32 m3;
    369
            bytes32 m4;
    370
            /// @solidity memory-safe-assembly
    371
            assembly {
    372
                function writeString(pos, w) {
    373
                    let length := 0
    374
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    375
                    mstore(pos, length)
    376
                    let shift := sub(256, shl(3, length))
    377
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    378
                }
    379
                m0 := mload(0x00)
    380
                m1 := mload(0x20)
    381
                m2 := mload(0x40)
    382
                m3 := mload(0x60)
    383
                m4 := mload(0x80)
    384
                // Selector of `log(bool,string)`.
    385
                mstore(0x00, 0x8feac525)
    386
                mstore(0x20, p0)
    387
                mstore(0x40, 0x40)
    388
                writeString(0x60, p1)
    389
            }
    390
            _sendLogPayload(0x1c, 0x84);
    391
            /// @solidity memory-safe-assembly
    392
            assembly {
    393
                mstore(0x00, m0)
    394
                mstore(0x20, m1)
    395
                mstore(0x40, m2)
    396
                mstore(0x60, m3)
    397
                mstore(0x80, m4)
    398
            }
    399
        }
    400
    
                                                    
                                                
    401
        function log(uint256 p0, address p1) internal pure {
    402
            bytes32 m0;
    403
            bytes32 m1;
    404
            bytes32 m2;
    405
            /// @solidity memory-safe-assembly
    406
            assembly {
    407
                m0 := mload(0x00)
    408
                m1 := mload(0x20)
    409
                m2 := mload(0x40)
    410
                // Selector of `log(uint256,address)`.
    411
                mstore(0x00, 0x69276c86)
    412
                mstore(0x20, p0)
    413
                mstore(0x40, p1)
    414
            }
    415
            _sendLogPayload(0x1c, 0x44);
    416
            /// @solidity memory-safe-assembly
    417
            assembly {
    418
                mstore(0x00, m0)
    419
                mstore(0x20, m1)
    420
                mstore(0x40, m2)
    421
            }
    422
        }
    423
    
                                                    
                                                
    424
        function log(uint256 p0, bool p1) internal pure {
    425
            bytes32 m0;
    426
            bytes32 m1;
    427
            bytes32 m2;
    428
            /// @solidity memory-safe-assembly
    429
            assembly {
    430
                m0 := mload(0x00)
    431
                m1 := mload(0x20)
    432
                m2 := mload(0x40)
    433
                // Selector of `log(uint256,bool)`.
    434
                mstore(0x00, 0x1c9d7eb3)
    435
                mstore(0x20, p0)
    436
                mstore(0x40, p1)
    437
            }
    438
            _sendLogPayload(0x1c, 0x44);
    439
            /// @solidity memory-safe-assembly
    440
            assembly {
    441
                mstore(0x00, m0)
    442
                mstore(0x20, m1)
    443
                mstore(0x40, m2)
    444
            }
    445
        }
    446
    
                                                    
                                                
    447
        function log(uint256 p0, uint256 p1) internal pure {
    448
            bytes32 m0;
    449
            bytes32 m1;
    450
            bytes32 m2;
    451
            /// @solidity memory-safe-assembly
    452
            assembly {
    453
                m0 := mload(0x00)
    454
                m1 := mload(0x20)
    455
                m2 := mload(0x40)
    456
                // Selector of `log(uint256,uint256)`.
    457
                mstore(0x00, 0xf666715a)
    458
                mstore(0x20, p0)
    459
                mstore(0x40, p1)
    460
            }
    461
            _sendLogPayload(0x1c, 0x44);
    462
            /// @solidity memory-safe-assembly
    463
            assembly {
    464
                mstore(0x00, m0)
    465
                mstore(0x20, m1)
    466
                mstore(0x40, m2)
    467
            }
    468
        }
    469
    
                                                    
                                                
    470
        function log(uint256 p0, bytes32 p1) internal pure {
    471
            bytes32 m0;
    472
            bytes32 m1;
    473
            bytes32 m2;
    474
            bytes32 m3;
    475
            bytes32 m4;
    476
            /// @solidity memory-safe-assembly
    477
            assembly {
    478
                function writeString(pos, w) {
    479
                    let length := 0
    480
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    481
                    mstore(pos, length)
    482
                    let shift := sub(256, shl(3, length))
    483
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    484
                }
    485
                m0 := mload(0x00)
    486
                m1 := mload(0x20)
    487
                m2 := mload(0x40)
    488
                m3 := mload(0x60)
    489
                m4 := mload(0x80)
    490
                // Selector of `log(uint256,string)`.
    491
                mstore(0x00, 0x643fd0df)
    492
                mstore(0x20, p0)
    493
                mstore(0x40, 0x40)
    494
                writeString(0x60, p1)
    495
            }
    496
            _sendLogPayload(0x1c, 0x84);
    497
            /// @solidity memory-safe-assembly
    498
            assembly {
    499
                mstore(0x00, m0)
    500
                mstore(0x20, m1)
    501
                mstore(0x40, m2)
    502
                mstore(0x60, m3)
    503
                mstore(0x80, m4)
    504
            }
    505
        }
    506
    
                                                    
                                                
    507
        function log(bytes32 p0, address p1) internal pure {
    508
            bytes32 m0;
    509
            bytes32 m1;
    510
            bytes32 m2;
    511
            bytes32 m3;
    512
            bytes32 m4;
    513
            /// @solidity memory-safe-assembly
    514
            assembly {
    515
                function writeString(pos, w) {
    516
                    let length := 0
    517
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    518
                    mstore(pos, length)
    519
                    let shift := sub(256, shl(3, length))
    520
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    521
                }
    522
                m0 := mload(0x00)
    523
                m1 := mload(0x20)
    524
                m2 := mload(0x40)
    525
                m3 := mload(0x60)
    526
                m4 := mload(0x80)
    527
                // Selector of `log(string,address)`.
    528
                mstore(0x00, 0x319af333)
    529
                mstore(0x20, 0x40)
    530
                mstore(0x40, p1)
    531
                writeString(0x60, p0)
    532
            }
    533
            _sendLogPayload(0x1c, 0x84);
    534
            /// @solidity memory-safe-assembly
    535
            assembly {
    536
                mstore(0x00, m0)
    537
                mstore(0x20, m1)
    538
                mstore(0x40, m2)
    539
                mstore(0x60, m3)
    540
                mstore(0x80, m4)
    541
            }
    542
        }
    543
    
                                                    
                                                
    544
        function log(bytes32 p0, bool p1) internal pure {
    545
            bytes32 m0;
    546
            bytes32 m1;
    547
            bytes32 m2;
    548
            bytes32 m3;
    549
            bytes32 m4;
    550
            /// @solidity memory-safe-assembly
    551
            assembly {
    552
                function writeString(pos, w) {
    553
                    let length := 0
    554
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    555
                    mstore(pos, length)
    556
                    let shift := sub(256, shl(3, length))
    557
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    558
                }
    559
                m0 := mload(0x00)
    560
                m1 := mload(0x20)
    561
                m2 := mload(0x40)
    562
                m3 := mload(0x60)
    563
                m4 := mload(0x80)
    564
                // Selector of `log(string,bool)`.
    565
                mstore(0x00, 0xc3b55635)
    566
                mstore(0x20, 0x40)
    567
                mstore(0x40, p1)
    568
                writeString(0x60, p0)
    569
            }
    570
            _sendLogPayload(0x1c, 0x84);
    571
            /// @solidity memory-safe-assembly
    572
            assembly {
    573
                mstore(0x00, m0)
    574
                mstore(0x20, m1)
    575
                mstore(0x40, m2)
    576
                mstore(0x60, m3)
    577
                mstore(0x80, m4)
    578
            }
    579
        }
    580
    
                                                    
                                                
    581
        function log(bytes32 p0, uint256 p1) internal pure {
    582
            bytes32 m0;
    583
            bytes32 m1;
    584
            bytes32 m2;
    585
            bytes32 m3;
    586
            bytes32 m4;
    587
            /// @solidity memory-safe-assembly
    588
            assembly {
    589
                function writeString(pos, w) {
    590
                    let length := 0
    591
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    592
                    mstore(pos, length)
    593
                    let shift := sub(256, shl(3, length))
    594
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    595
                }
    596
                m0 := mload(0x00)
    597
                m1 := mload(0x20)
    598
                m2 := mload(0x40)
    599
                m3 := mload(0x60)
    600
                m4 := mload(0x80)
    601
                // Selector of `log(string,uint256)`.
    602
                mstore(0x00, 0xb60e72cc)
    603
                mstore(0x20, 0x40)
    604
                mstore(0x40, p1)
    605
                writeString(0x60, p0)
    606
            }
    607
            _sendLogPayload(0x1c, 0x84);
    608
            /// @solidity memory-safe-assembly
    609
            assembly {
    610
                mstore(0x00, m0)
    611
                mstore(0x20, m1)
    612
                mstore(0x40, m2)
    613
                mstore(0x60, m3)
    614
                mstore(0x80, m4)
    615
            }
    616
        }
    617
    
                                                    
                                                
    618
        function log(bytes32 p0, bytes32 p1) internal pure {
    619
            bytes32 m0;
    620
            bytes32 m1;
    621
            bytes32 m2;
    622
            bytes32 m3;
    623
            bytes32 m4;
    624
            bytes32 m5;
    625
            bytes32 m6;
    626
            /// @solidity memory-safe-assembly
    627
            assembly {
    628
                function writeString(pos, w) {
    629
                    let length := 0
    630
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    631
                    mstore(pos, length)
    632
                    let shift := sub(256, shl(3, length))
    633
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    634
                }
    635
                m0 := mload(0x00)
    636
                m1 := mload(0x20)
    637
                m2 := mload(0x40)
    638
                m3 := mload(0x60)
    639
                m4 := mload(0x80)
    640
                m5 := mload(0xa0)
    641
                m6 := mload(0xc0)
    642
                // Selector of `log(string,string)`.
    643
                mstore(0x00, 0x4b5c4277)
    644
                mstore(0x20, 0x40)
    645
                mstore(0x40, 0x80)
    646
                writeString(0x60, p0)
    647
                writeString(0xa0, p1)
    648
            }
    649
            _sendLogPayload(0x1c, 0xc4);
    650
            /// @solidity memory-safe-assembly
    651
            assembly {
    652
                mstore(0x00, m0)
    653
                mstore(0x20, m1)
    654
                mstore(0x40, m2)
    655
                mstore(0x60, m3)
    656
                mstore(0x80, m4)
    657
                mstore(0xa0, m5)
    658
                mstore(0xc0, m6)
    659
            }
    660
        }
    661
    
                                                    
                                                
    662
        function log(address p0, address p1, address p2) internal pure {
    663
            bytes32 m0;
    664
            bytes32 m1;
    665
            bytes32 m2;
    666
            bytes32 m3;
    667
            /// @solidity memory-safe-assembly
    668
            assembly {
    669
                m0 := mload(0x00)
    670
                m1 := mload(0x20)
    671
                m2 := mload(0x40)
    672
                m3 := mload(0x60)
    673
                // Selector of `log(address,address,address)`.
    674
                mstore(0x00, 0x018c84c2)
    675
                mstore(0x20, p0)
    676
                mstore(0x40, p1)
    677
                mstore(0x60, p2)
    678
            }
    679
            _sendLogPayload(0x1c, 0x64);
    680
            /// @solidity memory-safe-assembly
    681
            assembly {
    682
                mstore(0x00, m0)
    683
                mstore(0x20, m1)
    684
                mstore(0x40, m2)
    685
                mstore(0x60, m3)
    686
            }
    687
        }
    688
    
                                                    
                                                
    689
        function log(address p0, address p1, bool p2) internal pure {
    690
            bytes32 m0;
    691
            bytes32 m1;
    692
            bytes32 m2;
    693
            bytes32 m3;
    694
            /// @solidity memory-safe-assembly
    695
            assembly {
    696
                m0 := mload(0x00)
    697
                m1 := mload(0x20)
    698
                m2 := mload(0x40)
    699
                m3 := mload(0x60)
    700
                // Selector of `log(address,address,bool)`.
    701
                mstore(0x00, 0xf2a66286)
    702
                mstore(0x20, p0)
    703
                mstore(0x40, p1)
    704
                mstore(0x60, p2)
    705
            }
    706
            _sendLogPayload(0x1c, 0x64);
    707
            /// @solidity memory-safe-assembly
    708
            assembly {
    709
                mstore(0x00, m0)
    710
                mstore(0x20, m1)
    711
                mstore(0x40, m2)
    712
                mstore(0x60, m3)
    713
            }
    714
        }
    715
    
                                                    
                                                
    716
        function log(address p0, address p1, uint256 p2) internal pure {
    717
            bytes32 m0;
    718
            bytes32 m1;
    719
            bytes32 m2;
    720
            bytes32 m3;
    721
            /// @solidity memory-safe-assembly
    722
            assembly {
    723
                m0 := mload(0x00)
    724
                m1 := mload(0x20)
    725
                m2 := mload(0x40)
    726
                m3 := mload(0x60)
    727
                // Selector of `log(address,address,uint256)`.
    728
                mstore(0x00, 0x17fe6185)
    729
                mstore(0x20, p0)
    730
                mstore(0x40, p1)
    731
                mstore(0x60, p2)
    732
            }
    733
            _sendLogPayload(0x1c, 0x64);
    734
            /// @solidity memory-safe-assembly
    735
            assembly {
    736
                mstore(0x00, m0)
    737
                mstore(0x20, m1)
    738
                mstore(0x40, m2)
    739
                mstore(0x60, m3)
    740
            }
    741
        }
    742
    
                                                    
                                                
    743
        function log(address p0, address p1, bytes32 p2) internal pure {
    744
            bytes32 m0;
    745
            bytes32 m1;
    746
            bytes32 m2;
    747
            bytes32 m3;
    748
            bytes32 m4;
    749
            bytes32 m5;
    750
            /// @solidity memory-safe-assembly
    751
            assembly {
    752
                function writeString(pos, w) {
    753
                    let length := 0
    754
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    755
                    mstore(pos, length)
    756
                    let shift := sub(256, shl(3, length))
    757
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    758
                }
    759
                m0 := mload(0x00)
    760
                m1 := mload(0x20)
    761
                m2 := mload(0x40)
    762
                m3 := mload(0x60)
    763
                m4 := mload(0x80)
    764
                m5 := mload(0xa0)
    765
                // Selector of `log(address,address,string)`.
    766
                mstore(0x00, 0x007150be)
    767
                mstore(0x20, p0)
    768
                mstore(0x40, p1)
    769
                mstore(0x60, 0x60)
    770
                writeString(0x80, p2)
    771
            }
    772
            _sendLogPayload(0x1c, 0xa4);
    773
            /// @solidity memory-safe-assembly
    774
            assembly {
    775
                mstore(0x00, m0)
    776
                mstore(0x20, m1)
    777
                mstore(0x40, m2)
    778
                mstore(0x60, m3)
    779
                mstore(0x80, m4)
    780
                mstore(0xa0, m5)
    781
            }
    782
        }
    783
    
                                                    
                                                
    784
        function log(address p0, bool p1, address p2) internal pure {
    785
            bytes32 m0;
    786
            bytes32 m1;
    787
            bytes32 m2;
    788
            bytes32 m3;
    789
            /// @solidity memory-safe-assembly
    790
            assembly {
    791
                m0 := mload(0x00)
    792
                m1 := mload(0x20)
    793
                m2 := mload(0x40)
    794
                m3 := mload(0x60)
    795
                // Selector of `log(address,bool,address)`.
    796
                mstore(0x00, 0xf11699ed)
    797
                mstore(0x20, p0)
    798
                mstore(0x40, p1)
    799
                mstore(0x60, p2)
    800
            }
    801
            _sendLogPayload(0x1c, 0x64);
    802
            /// @solidity memory-safe-assembly
    803
            assembly {
    804
                mstore(0x00, m0)
    805
                mstore(0x20, m1)
    806
                mstore(0x40, m2)
    807
                mstore(0x60, m3)
    808
            }
    809
        }
    810
    
                                                    
                                                
    811
        function log(address p0, bool p1, bool p2) internal pure {
    812
            bytes32 m0;
    813
            bytes32 m1;
    814
            bytes32 m2;
    815
            bytes32 m3;
    816
            /// @solidity memory-safe-assembly
    817
            assembly {
    818
                m0 := mload(0x00)
    819
                m1 := mload(0x20)
    820
                m2 := mload(0x40)
    821
                m3 := mload(0x60)
    822
                // Selector of `log(address,bool,bool)`.
    823
                mstore(0x00, 0xeb830c92)
    824
                mstore(0x20, p0)
    825
                mstore(0x40, p1)
    826
                mstore(0x60, p2)
    827
            }
    828
            _sendLogPayload(0x1c, 0x64);
    829
            /// @solidity memory-safe-assembly
    830
            assembly {
    831
                mstore(0x00, m0)
    832
                mstore(0x20, m1)
    833
                mstore(0x40, m2)
    834
                mstore(0x60, m3)
    835
            }
    836
        }
    837
    
                                                    
                                                
    838
        function log(address p0, bool p1, uint256 p2) internal pure {
    839
            bytes32 m0;
    840
            bytes32 m1;
    841
            bytes32 m2;
    842
            bytes32 m3;
    843
            /// @solidity memory-safe-assembly
    844
            assembly {
    845
                m0 := mload(0x00)
    846
                m1 := mload(0x20)
    847
                m2 := mload(0x40)
    848
                m3 := mload(0x60)
    849
                // Selector of `log(address,bool,uint256)`.
    850
                mstore(0x00, 0x9c4f99fb)
    851
                mstore(0x20, p0)
    852
                mstore(0x40, p1)
    853
                mstore(0x60, p2)
    854
            }
    855
            _sendLogPayload(0x1c, 0x64);
    856
            /// @solidity memory-safe-assembly
    857
            assembly {
    858
                mstore(0x00, m0)
    859
                mstore(0x20, m1)
    860
                mstore(0x40, m2)
    861
                mstore(0x60, m3)
    862
            }
    863
        }
    864
    
                                                    
                                                
    865
        function log(address p0, bool p1, bytes32 p2) internal pure {
    866
            bytes32 m0;
    867
            bytes32 m1;
    868
            bytes32 m2;
    869
            bytes32 m3;
    870
            bytes32 m4;
    871
            bytes32 m5;
    872
            /// @solidity memory-safe-assembly
    873
            assembly {
    874
                function writeString(pos, w) {
    875
                    let length := 0
    876
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    877
                    mstore(pos, length)
    878
                    let shift := sub(256, shl(3, length))
    879
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    880
                }
    881
                m0 := mload(0x00)
    882
                m1 := mload(0x20)
    883
                m2 := mload(0x40)
    884
                m3 := mload(0x60)
    885
                m4 := mload(0x80)
    886
                m5 := mload(0xa0)
    887
                // Selector of `log(address,bool,string)`.
    888
                mstore(0x00, 0x212255cc)
    889
                mstore(0x20, p0)
    890
                mstore(0x40, p1)
    891
                mstore(0x60, 0x60)
    892
                writeString(0x80, p2)
    893
            }
    894
            _sendLogPayload(0x1c, 0xa4);
    895
            /// @solidity memory-safe-assembly
    896
            assembly {
    897
                mstore(0x00, m0)
    898
                mstore(0x20, m1)
    899
                mstore(0x40, m2)
    900
                mstore(0x60, m3)
    901
                mstore(0x80, m4)
    902
                mstore(0xa0, m5)
    903
            }
    904
        }
    905
    
                                                    
                                                
    906
        function log(address p0, uint256 p1, address p2) internal pure {
    907
            bytes32 m0;
    908
            bytes32 m1;
    909
            bytes32 m2;
    910
            bytes32 m3;
    911
            /// @solidity memory-safe-assembly
    912
            assembly {
    913
                m0 := mload(0x00)
    914
                m1 := mload(0x20)
    915
                m2 := mload(0x40)
    916
                m3 := mload(0x60)
    917
                // Selector of `log(address,uint256,address)`.
    918
                mstore(0x00, 0x7bc0d848)
    919
                mstore(0x20, p0)
    920
                mstore(0x40, p1)
    921
                mstore(0x60, p2)
    922
            }
    923
            _sendLogPayload(0x1c, 0x64);
    924
            /// @solidity memory-safe-assembly
    925
            assembly {
    926
                mstore(0x00, m0)
    927
                mstore(0x20, m1)
    928
                mstore(0x40, m2)
    929
                mstore(0x60, m3)
    930
            }
    931
        }
    932
    
                                                    
                                                
    933
        function log(address p0, uint256 p1, bool p2) internal pure {
    934
            bytes32 m0;
    935
            bytes32 m1;
    936
            bytes32 m2;
    937
            bytes32 m3;
    938
            /// @solidity memory-safe-assembly
    939
            assembly {
    940
                m0 := mload(0x00)
    941
                m1 := mload(0x20)
    942
                m2 := mload(0x40)
    943
                m3 := mload(0x60)
    944
                // Selector of `log(address,uint256,bool)`.
    945
                mstore(0x00, 0x678209a8)
    946
                mstore(0x20, p0)
    947
                mstore(0x40, p1)
    948
                mstore(0x60, p2)
    949
            }
    950
            _sendLogPayload(0x1c, 0x64);
    951
            /// @solidity memory-safe-assembly
    952
            assembly {
    953
                mstore(0x00, m0)
    954
                mstore(0x20, m1)
    955
                mstore(0x40, m2)
    956
                mstore(0x60, m3)
    957
            }
    958
        }
    959
    
                                                    
                                                
    960
        function log(address p0, uint256 p1, uint256 p2) internal pure {
    961
            bytes32 m0;
    962
            bytes32 m1;
    963
            bytes32 m2;
    964
            bytes32 m3;
    965
            /// @solidity memory-safe-assembly
    966
            assembly {
    967
                m0 := mload(0x00)
    968
                m1 := mload(0x20)
    969
                m2 := mload(0x40)
    970
                m3 := mload(0x60)
    971
                // Selector of `log(address,uint256,uint256)`.
    972
                mstore(0x00, 0xb69bcaf6)
    973
                mstore(0x20, p0)
    974
                mstore(0x40, p1)
    975
                mstore(0x60, p2)
    976
            }
    977
            _sendLogPayload(0x1c, 0x64);
    978
            /// @solidity memory-safe-assembly
    979
            assembly {
    980
                mstore(0x00, m0)
    981
                mstore(0x20, m1)
    982
                mstore(0x40, m2)
    983
                mstore(0x60, m3)
    984
            }
    985
        }
    986
    
                                                    
                                                
    987
        function log(address p0, uint256 p1, bytes32 p2) internal pure {
    988
            bytes32 m0;
    989
            bytes32 m1;
    990
            bytes32 m2;
    991
            bytes32 m3;
    992
            bytes32 m4;
    993
            bytes32 m5;
    994
            /// @solidity memory-safe-assembly
    995
            assembly {
    996
                function writeString(pos, w) {
    997
                    let length := 0
    998
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    999
                    mstore(pos, length)
    1000
                    let shift := sub(256, shl(3, length))
    1001
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1002
                }
    1003
                m0 := mload(0x00)
    1004
                m1 := mload(0x20)
    1005
                m2 := mload(0x40)
    1006
                m3 := mload(0x60)
    1007
                m4 := mload(0x80)
    1008
                m5 := mload(0xa0)
    1009
                // Selector of `log(address,uint256,string)`.
    1010
                mstore(0x00, 0xa1f2e8aa)
    1011
                mstore(0x20, p0)
    1012
                mstore(0x40, p1)
    1013
                mstore(0x60, 0x60)
    1014
                writeString(0x80, p2)
    1015
            }
    1016
            _sendLogPayload(0x1c, 0xa4);
    1017
            /// @solidity memory-safe-assembly
    1018
            assembly {
    1019
                mstore(0x00, m0)
    1020
                mstore(0x20, m1)
    1021
                mstore(0x40, m2)
    1022
                mstore(0x60, m3)
    1023
                mstore(0x80, m4)
    1024
                mstore(0xa0, m5)
    1025
            }
    1026
        }
    1027
    
                                                    
                                                
    1028
        function log(address p0, bytes32 p1, address p2) internal pure {
    1029
            bytes32 m0;
    1030
            bytes32 m1;
    1031
            bytes32 m2;
    1032
            bytes32 m3;
    1033
            bytes32 m4;
    1034
            bytes32 m5;
    1035
            /// @solidity memory-safe-assembly
    1036
            assembly {
    1037
                function writeString(pos, w) {
    1038
                    let length := 0
    1039
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1040
                    mstore(pos, length)
    1041
                    let shift := sub(256, shl(3, length))
    1042
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1043
                }
    1044
                m0 := mload(0x00)
    1045
                m1 := mload(0x20)
    1046
                m2 := mload(0x40)
    1047
                m3 := mload(0x60)
    1048
                m4 := mload(0x80)
    1049
                m5 := mload(0xa0)
    1050
                // Selector of `log(address,string,address)`.
    1051
                mstore(0x00, 0xf08744e8)
    1052
                mstore(0x20, p0)
    1053
                mstore(0x40, 0x60)
    1054
                mstore(0x60, p2)
    1055
                writeString(0x80, p1)
    1056
            }
    1057
            _sendLogPayload(0x1c, 0xa4);
    1058
            /// @solidity memory-safe-assembly
    1059
            assembly {
    1060
                mstore(0x00, m0)
    1061
                mstore(0x20, m1)
    1062
                mstore(0x40, m2)
    1063
                mstore(0x60, m3)
    1064
                mstore(0x80, m4)
    1065
                mstore(0xa0, m5)
    1066
            }
    1067
        }
    1068
    
                                                    
                                                
    1069
        function log(address p0, bytes32 p1, bool p2) internal pure {
    1070
            bytes32 m0;
    1071
            bytes32 m1;
    1072
            bytes32 m2;
    1073
            bytes32 m3;
    1074
            bytes32 m4;
    1075
            bytes32 m5;
    1076
            /// @solidity memory-safe-assembly
    1077
            assembly {
    1078
                function writeString(pos, w) {
    1079
                    let length := 0
    1080
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1081
                    mstore(pos, length)
    1082
                    let shift := sub(256, shl(3, length))
    1083
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1084
                }
    1085
                m0 := mload(0x00)
    1086
                m1 := mload(0x20)
    1087
                m2 := mload(0x40)
    1088
                m3 := mload(0x60)
    1089
                m4 := mload(0x80)
    1090
                m5 := mload(0xa0)
    1091
                // Selector of `log(address,string,bool)`.
    1092
                mstore(0x00, 0xcf020fb1)
    1093
                mstore(0x20, p0)
    1094
                mstore(0x40, 0x60)
    1095
                mstore(0x60, p2)
    1096
                writeString(0x80, p1)
    1097
            }
    1098
            _sendLogPayload(0x1c, 0xa4);
    1099
            /// @solidity memory-safe-assembly
    1100
            assembly {
    1101
                mstore(0x00, m0)
    1102
                mstore(0x20, m1)
    1103
                mstore(0x40, m2)
    1104
                mstore(0x60, m3)
    1105
                mstore(0x80, m4)
    1106
                mstore(0xa0, m5)
    1107
            }
    1108
        }
    1109
    
                                                    
                                                
    1110
        function log(address p0, bytes32 p1, uint256 p2) internal pure {
    1111
            bytes32 m0;
    1112
            bytes32 m1;
    1113
            bytes32 m2;
    1114
            bytes32 m3;
    1115
            bytes32 m4;
    1116
            bytes32 m5;
    1117
            /// @solidity memory-safe-assembly
    1118
            assembly {
    1119
                function writeString(pos, w) {
    1120
                    let length := 0
    1121
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1122
                    mstore(pos, length)
    1123
                    let shift := sub(256, shl(3, length))
    1124
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1125
                }
    1126
                m0 := mload(0x00)
    1127
                m1 := mload(0x20)
    1128
                m2 := mload(0x40)
    1129
                m3 := mload(0x60)
    1130
                m4 := mload(0x80)
    1131
                m5 := mload(0xa0)
    1132
                // Selector of `log(address,string,uint256)`.
    1133
                mstore(0x00, 0x67dd6ff1)
    1134
                mstore(0x20, p0)
    1135
                mstore(0x40, 0x60)
    1136
                mstore(0x60, p2)
    1137
                writeString(0x80, p1)
    1138
            }
    1139
            _sendLogPayload(0x1c, 0xa4);
    1140
            /// @solidity memory-safe-assembly
    1141
            assembly {
    1142
                mstore(0x00, m0)
    1143
                mstore(0x20, m1)
    1144
                mstore(0x40, m2)
    1145
                mstore(0x60, m3)
    1146
                mstore(0x80, m4)
    1147
                mstore(0xa0, m5)
    1148
            }
    1149
        }
    1150
    
                                                    
                                                
    1151
        function log(address p0, bytes32 p1, bytes32 p2) internal pure {
    1152
            bytes32 m0;
    1153
            bytes32 m1;
    1154
            bytes32 m2;
    1155
            bytes32 m3;
    1156
            bytes32 m4;
    1157
            bytes32 m5;
    1158
            bytes32 m6;
    1159
            bytes32 m7;
    1160
            /// @solidity memory-safe-assembly
    1161
            assembly {
    1162
                function writeString(pos, w) {
    1163
                    let length := 0
    1164
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1165
                    mstore(pos, length)
    1166
                    let shift := sub(256, shl(3, length))
    1167
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1168
                }
    1169
                m0 := mload(0x00)
    1170
                m1 := mload(0x20)
    1171
                m2 := mload(0x40)
    1172
                m3 := mload(0x60)
    1173
                m4 := mload(0x80)
    1174
                m5 := mload(0xa0)
    1175
                m6 := mload(0xc0)
    1176
                m7 := mload(0xe0)
    1177
                // Selector of `log(address,string,string)`.
    1178
                mstore(0x00, 0xfb772265)
    1179
                mstore(0x20, p0)
    1180
                mstore(0x40, 0x60)
    1181
                mstore(0x60, 0xa0)
    1182
                writeString(0x80, p1)
    1183
                writeString(0xc0, p2)
    1184
            }
    1185
            _sendLogPayload(0x1c, 0xe4);
    1186
            /// @solidity memory-safe-assembly
    1187
            assembly {
    1188
                mstore(0x00, m0)
    1189
                mstore(0x20, m1)
    1190
                mstore(0x40, m2)
    1191
                mstore(0x60, m3)
    1192
                mstore(0x80, m4)
    1193
                mstore(0xa0, m5)
    1194
                mstore(0xc0, m6)
    1195
                mstore(0xe0, m7)
    1196
            }
    1197
        }
    1198
    
                                                    
                                                
    1199
        function log(bool p0, address p1, address p2) internal pure {
    1200
            bytes32 m0;
    1201
            bytes32 m1;
    1202
            bytes32 m2;
    1203
            bytes32 m3;
    1204
            /// @solidity memory-safe-assembly
    1205
            assembly {
    1206
                m0 := mload(0x00)
    1207
                m1 := mload(0x20)
    1208
                m2 := mload(0x40)
    1209
                m3 := mload(0x60)
    1210
                // Selector of `log(bool,address,address)`.
    1211
                mstore(0x00, 0xd2763667)
    1212
                mstore(0x20, p0)
    1213
                mstore(0x40, p1)
    1214
                mstore(0x60, p2)
    1215
            }
    1216
            _sendLogPayload(0x1c, 0x64);
    1217
            /// @solidity memory-safe-assembly
    1218
            assembly {
    1219
                mstore(0x00, m0)
    1220
                mstore(0x20, m1)
    1221
                mstore(0x40, m2)
    1222
                mstore(0x60, m3)
    1223
            }
    1224
        }
    1225
    
                                                    
                                                
    1226
        function log(bool p0, address p1, bool p2) internal pure {
    1227
            bytes32 m0;
    1228
            bytes32 m1;
    1229
            bytes32 m2;
    1230
            bytes32 m3;
    1231
            /// @solidity memory-safe-assembly
    1232
            assembly {
    1233
                m0 := mload(0x00)
    1234
                m1 := mload(0x20)
    1235
                m2 := mload(0x40)
    1236
                m3 := mload(0x60)
    1237
                // Selector of `log(bool,address,bool)`.
    1238
                mstore(0x00, 0x18c9c746)
    1239
                mstore(0x20, p0)
    1240
                mstore(0x40, p1)
    1241
                mstore(0x60, p2)
    1242
            }
    1243
            _sendLogPayload(0x1c, 0x64);
    1244
            /// @solidity memory-safe-assembly
    1245
            assembly {
    1246
                mstore(0x00, m0)
    1247
                mstore(0x20, m1)
    1248
                mstore(0x40, m2)
    1249
                mstore(0x60, m3)
    1250
            }
    1251
        }
    1252
    
                                                    
                                                
    1253
        function log(bool p0, address p1, uint256 p2) internal pure {
    1254
            bytes32 m0;
    1255
            bytes32 m1;
    1256
            bytes32 m2;
    1257
            bytes32 m3;
    1258
            /// @solidity memory-safe-assembly
    1259
            assembly {
    1260
                m0 := mload(0x00)
    1261
                m1 := mload(0x20)
    1262
                m2 := mload(0x40)
    1263
                m3 := mload(0x60)
    1264
                // Selector of `log(bool,address,uint256)`.
    1265
                mstore(0x00, 0x5f7b9afb)
    1266
                mstore(0x20, p0)
    1267
                mstore(0x40, p1)
    1268
                mstore(0x60, p2)
    1269
            }
    1270
            _sendLogPayload(0x1c, 0x64);
    1271
            /// @solidity memory-safe-assembly
    1272
            assembly {
    1273
                mstore(0x00, m0)
    1274
                mstore(0x20, m1)
    1275
                mstore(0x40, m2)
    1276
                mstore(0x60, m3)
    1277
            }
    1278
        }
    1279
    
                                                    
                                                
    1280
        function log(bool p0, address p1, bytes32 p2) internal pure {
    1281
            bytes32 m0;
    1282
            bytes32 m1;
    1283
            bytes32 m2;
    1284
            bytes32 m3;
    1285
            bytes32 m4;
    1286
            bytes32 m5;
    1287
            /// @solidity memory-safe-assembly
    1288
            assembly {
    1289
                function writeString(pos, w) {
    1290
                    let length := 0
    1291
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1292
                    mstore(pos, length)
    1293
                    let shift := sub(256, shl(3, length))
    1294
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1295
                }
    1296
                m0 := mload(0x00)
    1297
                m1 := mload(0x20)
    1298
                m2 := mload(0x40)
    1299
                m3 := mload(0x60)
    1300
                m4 := mload(0x80)
    1301
                m5 := mload(0xa0)
    1302
                // Selector of `log(bool,address,string)`.
    1303
                mstore(0x00, 0xde9a9270)
    1304
                mstore(0x20, p0)
    1305
                mstore(0x40, p1)
    1306
                mstore(0x60, 0x60)
    1307
                writeString(0x80, p2)
    1308
            }
    1309
            _sendLogPayload(0x1c, 0xa4);
    1310
            /// @solidity memory-safe-assembly
    1311
            assembly {
    1312
                mstore(0x00, m0)
    1313
                mstore(0x20, m1)
    1314
                mstore(0x40, m2)
    1315
                mstore(0x60, m3)
    1316
                mstore(0x80, m4)
    1317
                mstore(0xa0, m5)
    1318
            }
    1319
        }
    1320
    
                                                    
                                                
    1321
        function log(bool p0, bool p1, address p2) internal pure {
    1322
            bytes32 m0;
    1323
            bytes32 m1;
    1324
            bytes32 m2;
    1325
            bytes32 m3;
    1326
            /// @solidity memory-safe-assembly
    1327
            assembly {
    1328
                m0 := mload(0x00)
    1329
                m1 := mload(0x20)
    1330
                m2 := mload(0x40)
    1331
                m3 := mload(0x60)
    1332
                // Selector of `log(bool,bool,address)`.
    1333
                mstore(0x00, 0x1078f68d)
    1334
                mstore(0x20, p0)
    1335
                mstore(0x40, p1)
    1336
                mstore(0x60, p2)
    1337
            }
    1338
            _sendLogPayload(0x1c, 0x64);
    1339
            /// @solidity memory-safe-assembly
    1340
            assembly {
    1341
                mstore(0x00, m0)
    1342
                mstore(0x20, m1)
    1343
                mstore(0x40, m2)
    1344
                mstore(0x60, m3)
    1345
            }
    1346
        }
    1347
    
                                                    
                                                
    1348
        function log(bool p0, bool p1, bool p2) internal pure {
    1349
            bytes32 m0;
    1350
            bytes32 m1;
    1351
            bytes32 m2;
    1352
            bytes32 m3;
    1353
            /// @solidity memory-safe-assembly
    1354
            assembly {
    1355
                m0 := mload(0x00)
    1356
                m1 := mload(0x20)
    1357
                m2 := mload(0x40)
    1358
                m3 := mload(0x60)
    1359
                // Selector of `log(bool,bool,bool)`.
    1360
                mstore(0x00, 0x50709698)
    1361
                mstore(0x20, p0)
    1362
                mstore(0x40, p1)
    1363
                mstore(0x60, p2)
    1364
            }
    1365
            _sendLogPayload(0x1c, 0x64);
    1366
            /// @solidity memory-safe-assembly
    1367
            assembly {
    1368
                mstore(0x00, m0)
    1369
                mstore(0x20, m1)
    1370
                mstore(0x40, m2)
    1371
                mstore(0x60, m3)
    1372
            }
    1373
        }
    1374
    
                                                    
                                                
    1375
        function log(bool p0, bool p1, uint256 p2) internal pure {
    1376
            bytes32 m0;
    1377
            bytes32 m1;
    1378
            bytes32 m2;
    1379
            bytes32 m3;
    1380
            /// @solidity memory-safe-assembly
    1381
            assembly {
    1382
                m0 := mload(0x00)
    1383
                m1 := mload(0x20)
    1384
                m2 := mload(0x40)
    1385
                m3 := mload(0x60)
    1386
                // Selector of `log(bool,bool,uint256)`.
    1387
                mstore(0x00, 0x12f21602)
    1388
                mstore(0x20, p0)
    1389
                mstore(0x40, p1)
    1390
                mstore(0x60, p2)
    1391
            }
    1392
            _sendLogPayload(0x1c, 0x64);
    1393
            /// @solidity memory-safe-assembly
    1394
            assembly {
    1395
                mstore(0x00, m0)
    1396
                mstore(0x20, m1)
    1397
                mstore(0x40, m2)
    1398
                mstore(0x60, m3)
    1399
            }
    1400
        }
    1401
    
                                                    
                                                
    1402
        function log(bool p0, bool p1, bytes32 p2) internal pure {
    1403
            bytes32 m0;
    1404
            bytes32 m1;
    1405
            bytes32 m2;
    1406
            bytes32 m3;
    1407
            bytes32 m4;
    1408
            bytes32 m5;
    1409
            /// @solidity memory-safe-assembly
    1410
            assembly {
    1411
                function writeString(pos, w) {
    1412
                    let length := 0
    1413
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1414
                    mstore(pos, length)
    1415
                    let shift := sub(256, shl(3, length))
    1416
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1417
                }
    1418
                m0 := mload(0x00)
    1419
                m1 := mload(0x20)
    1420
                m2 := mload(0x40)
    1421
                m3 := mload(0x60)
    1422
                m4 := mload(0x80)
    1423
                m5 := mload(0xa0)
    1424
                // Selector of `log(bool,bool,string)`.
    1425
                mstore(0x00, 0x2555fa46)
    1426
                mstore(0x20, p0)
    1427
                mstore(0x40, p1)
    1428
                mstore(0x60, 0x60)
    1429
                writeString(0x80, p2)
    1430
            }
    1431
            _sendLogPayload(0x1c, 0xa4);
    1432
            /// @solidity memory-safe-assembly
    1433
            assembly {
    1434
                mstore(0x00, m0)
    1435
                mstore(0x20, m1)
    1436
                mstore(0x40, m2)
    1437
                mstore(0x60, m3)
    1438
                mstore(0x80, m4)
    1439
                mstore(0xa0, m5)
    1440
            }
    1441
        }
    1442
    
                                                    
                                                
    1443
        function log(bool p0, uint256 p1, address p2) internal pure {
    1444
            bytes32 m0;
    1445
            bytes32 m1;
    1446
            bytes32 m2;
    1447
            bytes32 m3;
    1448
            /// @solidity memory-safe-assembly
    1449
            assembly {
    1450
                m0 := mload(0x00)
    1451
                m1 := mload(0x20)
    1452
                m2 := mload(0x40)
    1453
                m3 := mload(0x60)
    1454
                // Selector of `log(bool,uint256,address)`.
    1455
                mstore(0x00, 0x088ef9d2)
    1456
                mstore(0x20, p0)
    1457
                mstore(0x40, p1)
    1458
                mstore(0x60, p2)
    1459
            }
    1460
            _sendLogPayload(0x1c, 0x64);
    1461
            /// @solidity memory-safe-assembly
    1462
            assembly {
    1463
                mstore(0x00, m0)
    1464
                mstore(0x20, m1)
    1465
                mstore(0x40, m2)
    1466
                mstore(0x60, m3)
    1467
            }
    1468
        }
    1469
    
                                                    
                                                
    1470
        function log(bool p0, uint256 p1, bool p2) internal pure {
    1471
            bytes32 m0;
    1472
            bytes32 m1;
    1473
            bytes32 m2;
    1474
            bytes32 m3;
    1475
            /// @solidity memory-safe-assembly
    1476
            assembly {
    1477
                m0 := mload(0x00)
    1478
                m1 := mload(0x20)
    1479
                m2 := mload(0x40)
    1480
                m3 := mload(0x60)
    1481
                // Selector of `log(bool,uint256,bool)`.
    1482
                mstore(0x00, 0xe8defba9)
    1483
                mstore(0x20, p0)
    1484
                mstore(0x40, p1)
    1485
                mstore(0x60, p2)
    1486
            }
    1487
            _sendLogPayload(0x1c, 0x64);
    1488
            /// @solidity memory-safe-assembly
    1489
            assembly {
    1490
                mstore(0x00, m0)
    1491
                mstore(0x20, m1)
    1492
                mstore(0x40, m2)
    1493
                mstore(0x60, m3)
    1494
            }
    1495
        }
    1496
    
                                                    
                                                
    1497
        function log(bool p0, uint256 p1, uint256 p2) internal pure {
    1498
            bytes32 m0;
    1499
            bytes32 m1;
    1500
            bytes32 m2;
    1501
            bytes32 m3;
    1502
            /// @solidity memory-safe-assembly
    1503
            assembly {
    1504
                m0 := mload(0x00)
    1505
                m1 := mload(0x20)
    1506
                m2 := mload(0x40)
    1507
                m3 := mload(0x60)
    1508
                // Selector of `log(bool,uint256,uint256)`.
    1509
                mstore(0x00, 0x37103367)
    1510
                mstore(0x20, p0)
    1511
                mstore(0x40, p1)
    1512
                mstore(0x60, p2)
    1513
            }
    1514
            _sendLogPayload(0x1c, 0x64);
    1515
            /// @solidity memory-safe-assembly
    1516
            assembly {
    1517
                mstore(0x00, m0)
    1518
                mstore(0x20, m1)
    1519
                mstore(0x40, m2)
    1520
                mstore(0x60, m3)
    1521
            }
    1522
        }
    1523
    
                                                    
                                                
    1524
        function log(bool p0, uint256 p1, bytes32 p2) internal pure {
    1525
            bytes32 m0;
    1526
            bytes32 m1;
    1527
            bytes32 m2;
    1528
            bytes32 m3;
    1529
            bytes32 m4;
    1530
            bytes32 m5;
    1531
            /// @solidity memory-safe-assembly
    1532
            assembly {
    1533
                function writeString(pos, w) {
    1534
                    let length := 0
    1535
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1536
                    mstore(pos, length)
    1537
                    let shift := sub(256, shl(3, length))
    1538
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1539
                }
    1540
                m0 := mload(0x00)
    1541
                m1 := mload(0x20)
    1542
                m2 := mload(0x40)
    1543
                m3 := mload(0x60)
    1544
                m4 := mload(0x80)
    1545
                m5 := mload(0xa0)
    1546
                // Selector of `log(bool,uint256,string)`.
    1547
                mstore(0x00, 0xc3fc3970)
    1548
                mstore(0x20, p0)
    1549
                mstore(0x40, p1)
    1550
                mstore(0x60, 0x60)
    1551
                writeString(0x80, p2)
    1552
            }
    1553
            _sendLogPayload(0x1c, 0xa4);
    1554
            /// @solidity memory-safe-assembly
    1555
            assembly {
    1556
                mstore(0x00, m0)
    1557
                mstore(0x20, m1)
    1558
                mstore(0x40, m2)
    1559
                mstore(0x60, m3)
    1560
                mstore(0x80, m4)
    1561
                mstore(0xa0, m5)
    1562
            }
    1563
        }
    1564
    
                                                    
                                                
    1565
        function log(bool p0, bytes32 p1, address p2) internal pure {
    1566
            bytes32 m0;
    1567
            bytes32 m1;
    1568
            bytes32 m2;
    1569
            bytes32 m3;
    1570
            bytes32 m4;
    1571
            bytes32 m5;
    1572
            /// @solidity memory-safe-assembly
    1573
            assembly {
    1574
                function writeString(pos, w) {
    1575
                    let length := 0
    1576
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1577
                    mstore(pos, length)
    1578
                    let shift := sub(256, shl(3, length))
    1579
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1580
                }
    1581
                m0 := mload(0x00)
    1582
                m1 := mload(0x20)
    1583
                m2 := mload(0x40)
    1584
                m3 := mload(0x60)
    1585
                m4 := mload(0x80)
    1586
                m5 := mload(0xa0)
    1587
                // Selector of `log(bool,string,address)`.
    1588
                mstore(0x00, 0x9591b953)
    1589
                mstore(0x20, p0)
    1590
                mstore(0x40, 0x60)
    1591
                mstore(0x60, p2)
    1592
                writeString(0x80, p1)
    1593
            }
    1594
            _sendLogPayload(0x1c, 0xa4);
    1595
            /// @solidity memory-safe-assembly
    1596
            assembly {
    1597
                mstore(0x00, m0)
    1598
                mstore(0x20, m1)
    1599
                mstore(0x40, m2)
    1600
                mstore(0x60, m3)
    1601
                mstore(0x80, m4)
    1602
                mstore(0xa0, m5)
    1603
            }
    1604
        }
    1605
    
                                                    
                                                
    1606
        function log(bool p0, bytes32 p1, bool p2) internal pure {
    1607
            bytes32 m0;
    1608
            bytes32 m1;
    1609
            bytes32 m2;
    1610
            bytes32 m3;
    1611
            bytes32 m4;
    1612
            bytes32 m5;
    1613
            /// @solidity memory-safe-assembly
    1614
            assembly {
    1615
                function writeString(pos, w) {
    1616
                    let length := 0
    1617
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1618
                    mstore(pos, length)
    1619
                    let shift := sub(256, shl(3, length))
    1620
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1621
                }
    1622
                m0 := mload(0x00)
    1623
                m1 := mload(0x20)
    1624
                m2 := mload(0x40)
    1625
                m3 := mload(0x60)
    1626
                m4 := mload(0x80)
    1627
                m5 := mload(0xa0)
    1628
                // Selector of `log(bool,string,bool)`.
    1629
                mstore(0x00, 0xdbb4c247)
    1630
                mstore(0x20, p0)
    1631
                mstore(0x40, 0x60)
    1632
                mstore(0x60, p2)
    1633
                writeString(0x80, p1)
    1634
            }
    1635
            _sendLogPayload(0x1c, 0xa4);
    1636
            /// @solidity memory-safe-assembly
    1637
            assembly {
    1638
                mstore(0x00, m0)
    1639
                mstore(0x20, m1)
    1640
                mstore(0x40, m2)
    1641
                mstore(0x60, m3)
    1642
                mstore(0x80, m4)
    1643
                mstore(0xa0, m5)
    1644
            }
    1645
        }
    1646
    
                                                    
                                                
    1647
        function log(bool p0, bytes32 p1, uint256 p2) internal pure {
    1648
            bytes32 m0;
    1649
            bytes32 m1;
    1650
            bytes32 m2;
    1651
            bytes32 m3;
    1652
            bytes32 m4;
    1653
            bytes32 m5;
    1654
            /// @solidity memory-safe-assembly
    1655
            assembly {
    1656
                function writeString(pos, w) {
    1657
                    let length := 0
    1658
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1659
                    mstore(pos, length)
    1660
                    let shift := sub(256, shl(3, length))
    1661
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1662
                }
    1663
                m0 := mload(0x00)
    1664
                m1 := mload(0x20)
    1665
                m2 := mload(0x40)
    1666
                m3 := mload(0x60)
    1667
                m4 := mload(0x80)
    1668
                m5 := mload(0xa0)
    1669
                // Selector of `log(bool,string,uint256)`.
    1670
                mstore(0x00, 0x1093ee11)
    1671
                mstore(0x20, p0)
    1672
                mstore(0x40, 0x60)
    1673
                mstore(0x60, p2)
    1674
                writeString(0x80, p1)
    1675
            }
    1676
            _sendLogPayload(0x1c, 0xa4);
    1677
            /// @solidity memory-safe-assembly
    1678
            assembly {
    1679
                mstore(0x00, m0)
    1680
                mstore(0x20, m1)
    1681
                mstore(0x40, m2)
    1682
                mstore(0x60, m3)
    1683
                mstore(0x80, m4)
    1684
                mstore(0xa0, m5)
    1685
            }
    1686
        }
    1687
    
                                                    
                                                
    1688
        function log(bool p0, bytes32 p1, bytes32 p2) internal pure {
    1689
            bytes32 m0;
    1690
            bytes32 m1;
    1691
            bytes32 m2;
    1692
            bytes32 m3;
    1693
            bytes32 m4;
    1694
            bytes32 m5;
    1695
            bytes32 m6;
    1696
            bytes32 m7;
    1697
            /// @solidity memory-safe-assembly
    1698
            assembly {
    1699
                function writeString(pos, w) {
    1700
                    let length := 0
    1701
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1702
                    mstore(pos, length)
    1703
                    let shift := sub(256, shl(3, length))
    1704
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1705
                }
    1706
                m0 := mload(0x00)
    1707
                m1 := mload(0x20)
    1708
                m2 := mload(0x40)
    1709
                m3 := mload(0x60)
    1710
                m4 := mload(0x80)
    1711
                m5 := mload(0xa0)
    1712
                m6 := mload(0xc0)
    1713
                m7 := mload(0xe0)
    1714
                // Selector of `log(bool,string,string)`.
    1715
                mstore(0x00, 0xb076847f)
    1716
                mstore(0x20, p0)
    1717
                mstore(0x40, 0x60)
    1718
                mstore(0x60, 0xa0)
    1719
                writeString(0x80, p1)
    1720
                writeString(0xc0, p2)
    1721
            }
    1722
            _sendLogPayload(0x1c, 0xe4);
    1723
            /// @solidity memory-safe-assembly
    1724
            assembly {
    1725
                mstore(0x00, m0)
    1726
                mstore(0x20, m1)
    1727
                mstore(0x40, m2)
    1728
                mstore(0x60, m3)
    1729
                mstore(0x80, m4)
    1730
                mstore(0xa0, m5)
    1731
                mstore(0xc0, m6)
    1732
                mstore(0xe0, m7)
    1733
            }
    1734
        }
    1735
    
                                                    
                                                
    1736
        function log(uint256 p0, address p1, address p2) internal pure {
    1737
            bytes32 m0;
    1738
            bytes32 m1;
    1739
            bytes32 m2;
    1740
            bytes32 m3;
    1741
            /// @solidity memory-safe-assembly
    1742
            assembly {
    1743
                m0 := mload(0x00)
    1744
                m1 := mload(0x20)
    1745
                m2 := mload(0x40)
    1746
                m3 := mload(0x60)
    1747
                // Selector of `log(uint256,address,address)`.
    1748
                mstore(0x00, 0xbcfd9be0)
    1749
                mstore(0x20, p0)
    1750
                mstore(0x40, p1)
    1751
                mstore(0x60, p2)
    1752
            }
    1753
            _sendLogPayload(0x1c, 0x64);
    1754
            /// @solidity memory-safe-assembly
    1755
            assembly {
    1756
                mstore(0x00, m0)
    1757
                mstore(0x20, m1)
    1758
                mstore(0x40, m2)
    1759
                mstore(0x60, m3)
    1760
            }
    1761
        }
    1762
    
                                                    
                                                
    1763
        function log(uint256 p0, address p1, bool p2) internal pure {
    1764
            bytes32 m0;
    1765
            bytes32 m1;
    1766
            bytes32 m2;
    1767
            bytes32 m3;
    1768
            /// @solidity memory-safe-assembly
    1769
            assembly {
    1770
                m0 := mload(0x00)
    1771
                m1 := mload(0x20)
    1772
                m2 := mload(0x40)
    1773
                m3 := mload(0x60)
    1774
                // Selector of `log(uint256,address,bool)`.
    1775
                mstore(0x00, 0x9b6ec042)
    1776
                mstore(0x20, p0)
    1777
                mstore(0x40, p1)
    1778
                mstore(0x60, p2)
    1779
            }
    1780
            _sendLogPayload(0x1c, 0x64);
    1781
            /// @solidity memory-safe-assembly
    1782
            assembly {
    1783
                mstore(0x00, m0)
    1784
                mstore(0x20, m1)
    1785
                mstore(0x40, m2)
    1786
                mstore(0x60, m3)
    1787
            }
    1788
        }
    1789
    
                                                    
                                                
    1790
        function log(uint256 p0, address p1, uint256 p2) internal pure {
    1791
            bytes32 m0;
    1792
            bytes32 m1;
    1793
            bytes32 m2;
    1794
            bytes32 m3;
    1795
            /// @solidity memory-safe-assembly
    1796
            assembly {
    1797
                m0 := mload(0x00)
    1798
                m1 := mload(0x20)
    1799
                m2 := mload(0x40)
    1800
                m3 := mload(0x60)
    1801
                // Selector of `log(uint256,address,uint256)`.
    1802
                mstore(0x00, 0x5a9b5ed5)
    1803
                mstore(0x20, p0)
    1804
                mstore(0x40, p1)
    1805
                mstore(0x60, p2)
    1806
            }
    1807
            _sendLogPayload(0x1c, 0x64);
    1808
            /// @solidity memory-safe-assembly
    1809
            assembly {
    1810
                mstore(0x00, m0)
    1811
                mstore(0x20, m1)
    1812
                mstore(0x40, m2)
    1813
                mstore(0x60, m3)
    1814
            }
    1815
        }
    1816
    
                                                    
                                                
    1817
        function log(uint256 p0, address p1, bytes32 p2) internal pure {
    1818
            bytes32 m0;
    1819
            bytes32 m1;
    1820
            bytes32 m2;
    1821
            bytes32 m3;
    1822
            bytes32 m4;
    1823
            bytes32 m5;
    1824
            /// @solidity memory-safe-assembly
    1825
            assembly {
    1826
                function writeString(pos, w) {
    1827
                    let length := 0
    1828
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1829
                    mstore(pos, length)
    1830
                    let shift := sub(256, shl(3, length))
    1831
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1832
                }
    1833
                m0 := mload(0x00)
    1834
                m1 := mload(0x20)
    1835
                m2 := mload(0x40)
    1836
                m3 := mload(0x60)
    1837
                m4 := mload(0x80)
    1838
                m5 := mload(0xa0)
    1839
                // Selector of `log(uint256,address,string)`.
    1840
                mstore(0x00, 0x63cb41f9)
    1841
                mstore(0x20, p0)
    1842
                mstore(0x40, p1)
    1843
                mstore(0x60, 0x60)
    1844
                writeString(0x80, p2)
    1845
            }
    1846
            _sendLogPayload(0x1c, 0xa4);
    1847
            /// @solidity memory-safe-assembly
    1848
            assembly {
    1849
                mstore(0x00, m0)
    1850
                mstore(0x20, m1)
    1851
                mstore(0x40, m2)
    1852
                mstore(0x60, m3)
    1853
                mstore(0x80, m4)
    1854
                mstore(0xa0, m5)
    1855
            }
    1856
        }
    1857
    
                                                    
                                                
    1858
        function log(uint256 p0, bool p1, address p2) internal pure {
    1859
            bytes32 m0;
    1860
            bytes32 m1;
    1861
            bytes32 m2;
    1862
            bytes32 m3;
    1863
            /// @solidity memory-safe-assembly
    1864
            assembly {
    1865
                m0 := mload(0x00)
    1866
                m1 := mload(0x20)
    1867
                m2 := mload(0x40)
    1868
                m3 := mload(0x60)
    1869
                // Selector of `log(uint256,bool,address)`.
    1870
                mstore(0x00, 0x35085f7b)
    1871
                mstore(0x20, p0)
    1872
                mstore(0x40, p1)
    1873
                mstore(0x60, p2)
    1874
            }
    1875
            _sendLogPayload(0x1c, 0x64);
    1876
            /// @solidity memory-safe-assembly
    1877
            assembly {
    1878
                mstore(0x00, m0)
    1879
                mstore(0x20, m1)
    1880
                mstore(0x40, m2)
    1881
                mstore(0x60, m3)
    1882
            }
    1883
        }
    1884
    
                                                    
                                                
    1885
        function log(uint256 p0, bool p1, bool p2) internal pure {
    1886
            bytes32 m0;
    1887
            bytes32 m1;
    1888
            bytes32 m2;
    1889
            bytes32 m3;
    1890
            /// @solidity memory-safe-assembly
    1891
            assembly {
    1892
                m0 := mload(0x00)
    1893
                m1 := mload(0x20)
    1894
                m2 := mload(0x40)
    1895
                m3 := mload(0x60)
    1896
                // Selector of `log(uint256,bool,bool)`.
    1897
                mstore(0x00, 0x20718650)
    1898
                mstore(0x20, p0)
    1899
                mstore(0x40, p1)
    1900
                mstore(0x60, p2)
    1901
            }
    1902
            _sendLogPayload(0x1c, 0x64);
    1903
            /// @solidity memory-safe-assembly
    1904
            assembly {
    1905
                mstore(0x00, m0)
    1906
                mstore(0x20, m1)
    1907
                mstore(0x40, m2)
    1908
                mstore(0x60, m3)
    1909
            }
    1910
        }
    1911
    
                                                    
                                                
    1912
        function log(uint256 p0, bool p1, uint256 p2) internal pure {
    1913
            bytes32 m0;
    1914
            bytes32 m1;
    1915
            bytes32 m2;
    1916
            bytes32 m3;
    1917
            /// @solidity memory-safe-assembly
    1918
            assembly {
    1919
                m0 := mload(0x00)
    1920
                m1 := mload(0x20)
    1921
                m2 := mload(0x40)
    1922
                m3 := mload(0x60)
    1923
                // Selector of `log(uint256,bool,uint256)`.
    1924
                mstore(0x00, 0x20098014)
    1925
                mstore(0x20, p0)
    1926
                mstore(0x40, p1)
    1927
                mstore(0x60, p2)
    1928
            }
    1929
            _sendLogPayload(0x1c, 0x64);
    1930
            /// @solidity memory-safe-assembly
    1931
            assembly {
    1932
                mstore(0x00, m0)
    1933
                mstore(0x20, m1)
    1934
                mstore(0x40, m2)
    1935
                mstore(0x60, m3)
    1936
            }
    1937
        }
    1938
    
                                                    
                                                
    1939
        function log(uint256 p0, bool p1, bytes32 p2) internal pure {
    1940
            bytes32 m0;
    1941
            bytes32 m1;
    1942
            bytes32 m2;
    1943
            bytes32 m3;
    1944
            bytes32 m4;
    1945
            bytes32 m5;
    1946
            /// @solidity memory-safe-assembly
    1947
            assembly {
    1948
                function writeString(pos, w) {
    1949
                    let length := 0
    1950
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1951
                    mstore(pos, length)
    1952
                    let shift := sub(256, shl(3, length))
    1953
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1954
                }
    1955
                m0 := mload(0x00)
    1956
                m1 := mload(0x20)
    1957
                m2 := mload(0x40)
    1958
                m3 := mload(0x60)
    1959
                m4 := mload(0x80)
    1960
                m5 := mload(0xa0)
    1961
                // Selector of `log(uint256,bool,string)`.
    1962
                mstore(0x00, 0x85775021)
    1963
                mstore(0x20, p0)
    1964
                mstore(0x40, p1)
    1965
                mstore(0x60, 0x60)
    1966
                writeString(0x80, p2)
    1967
            }
    1968
            _sendLogPayload(0x1c, 0xa4);
    1969
            /// @solidity memory-safe-assembly
    1970
            assembly {
    1971
                mstore(0x00, m0)
    1972
                mstore(0x20, m1)
    1973
                mstore(0x40, m2)
    1974
                mstore(0x60, m3)
    1975
                mstore(0x80, m4)
    1976
                mstore(0xa0, m5)
    1977
            }
    1978
        }
    1979
    
                                                    
                                                
    1980
        function log(uint256 p0, uint256 p1, address p2) internal pure {
    1981
            bytes32 m0;
    1982
            bytes32 m1;
    1983
            bytes32 m2;
    1984
            bytes32 m3;
    1985
            /// @solidity memory-safe-assembly
    1986
            assembly {
    1987
                m0 := mload(0x00)
    1988
                m1 := mload(0x20)
    1989
                m2 := mload(0x40)
    1990
                m3 := mload(0x60)
    1991
                // Selector of `log(uint256,uint256,address)`.
    1992
                mstore(0x00, 0x5c96b331)
    1993
                mstore(0x20, p0)
    1994
                mstore(0x40, p1)
    1995
                mstore(0x60, p2)
    1996
            }
    1997
            _sendLogPayload(0x1c, 0x64);
    1998
            /// @solidity memory-safe-assembly
    1999
            assembly {
    2000
                mstore(0x00, m0)
    2001
                mstore(0x20, m1)
    2002
                mstore(0x40, m2)
    2003
                mstore(0x60, m3)
    2004
            }
    2005
        }
    2006
    
                                                    
                                                
    2007
        function log(uint256 p0, uint256 p1, bool p2) internal pure {
    2008
            bytes32 m0;
    2009
            bytes32 m1;
    2010
            bytes32 m2;
    2011
            bytes32 m3;
    2012
            /// @solidity memory-safe-assembly
    2013
            assembly {
    2014
                m0 := mload(0x00)
    2015
                m1 := mload(0x20)
    2016
                m2 := mload(0x40)
    2017
                m3 := mload(0x60)
    2018
                // Selector of `log(uint256,uint256,bool)`.
    2019
                mstore(0x00, 0x4766da72)
    2020
                mstore(0x20, p0)
    2021
                mstore(0x40, p1)
    2022
                mstore(0x60, p2)
    2023
            }
    2024
            _sendLogPayload(0x1c, 0x64);
    2025
            /// @solidity memory-safe-assembly
    2026
            assembly {
    2027
                mstore(0x00, m0)
    2028
                mstore(0x20, m1)
    2029
                mstore(0x40, m2)
    2030
                mstore(0x60, m3)
    2031
            }
    2032
        }
    2033
    
                                                    
                                                
    2034
        function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
    2035
            bytes32 m0;
    2036
            bytes32 m1;
    2037
            bytes32 m2;
    2038
            bytes32 m3;
    2039
            /// @solidity memory-safe-assembly
    2040
            assembly {
    2041
                m0 := mload(0x00)
    2042
                m1 := mload(0x20)
    2043
                m2 := mload(0x40)
    2044
                m3 := mload(0x60)
    2045
                // Selector of `log(uint256,uint256,uint256)`.
    2046
                mstore(0x00, 0xd1ed7a3c)
    2047
                mstore(0x20, p0)
    2048
                mstore(0x40, p1)
    2049
                mstore(0x60, p2)
    2050
            }
    2051
            _sendLogPayload(0x1c, 0x64);
    2052
            /// @solidity memory-safe-assembly
    2053
            assembly {
    2054
                mstore(0x00, m0)
    2055
                mstore(0x20, m1)
    2056
                mstore(0x40, m2)
    2057
                mstore(0x60, m3)
    2058
            }
    2059
        }
    2060
    
                                                    
                                                
    2061
        function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {
    2062
            bytes32 m0;
    2063
            bytes32 m1;
    2064
            bytes32 m2;
    2065
            bytes32 m3;
    2066
            bytes32 m4;
    2067
            bytes32 m5;
    2068
            /// @solidity memory-safe-assembly
    2069
            assembly {
    2070
                function writeString(pos, w) {
    2071
                    let length := 0
    2072
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2073
                    mstore(pos, length)
    2074
                    let shift := sub(256, shl(3, length))
    2075
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2076
                }
    2077
                m0 := mload(0x00)
    2078
                m1 := mload(0x20)
    2079
                m2 := mload(0x40)
    2080
                m3 := mload(0x60)
    2081
                m4 := mload(0x80)
    2082
                m5 := mload(0xa0)
    2083
                // Selector of `log(uint256,uint256,string)`.
    2084
                mstore(0x00, 0x71d04af2)
    2085
                mstore(0x20, p0)
    2086
                mstore(0x40, p1)
    2087
                mstore(0x60, 0x60)
    2088
                writeString(0x80, p2)
    2089
            }
    2090
            _sendLogPayload(0x1c, 0xa4);
    2091
            /// @solidity memory-safe-assembly
    2092
            assembly {
    2093
                mstore(0x00, m0)
    2094
                mstore(0x20, m1)
    2095
                mstore(0x40, m2)
    2096
                mstore(0x60, m3)
    2097
                mstore(0x80, m4)
    2098
                mstore(0xa0, m5)
    2099
            }
    2100
        }
    2101
    
                                                    
                                                
    2102
        function log(uint256 p0, bytes32 p1, address p2) internal pure {
    2103
            bytes32 m0;
    2104
            bytes32 m1;
    2105
            bytes32 m2;
    2106
            bytes32 m3;
    2107
            bytes32 m4;
    2108
            bytes32 m5;
    2109
            /// @solidity memory-safe-assembly
    2110
            assembly {
    2111
                function writeString(pos, w) {
    2112
                    let length := 0
    2113
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2114
                    mstore(pos, length)
    2115
                    let shift := sub(256, shl(3, length))
    2116
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2117
                }
    2118
                m0 := mload(0x00)
    2119
                m1 := mload(0x20)
    2120
                m2 := mload(0x40)
    2121
                m3 := mload(0x60)
    2122
                m4 := mload(0x80)
    2123
                m5 := mload(0xa0)
    2124
                // Selector of `log(uint256,string,address)`.
    2125
                mstore(0x00, 0x7afac959)
    2126
                mstore(0x20, p0)
    2127
                mstore(0x40, 0x60)
    2128
                mstore(0x60, p2)
    2129
                writeString(0x80, p1)
    2130
            }
    2131
            _sendLogPayload(0x1c, 0xa4);
    2132
            /// @solidity memory-safe-assembly
    2133
            assembly {
    2134
                mstore(0x00, m0)
    2135
                mstore(0x20, m1)
    2136
                mstore(0x40, m2)
    2137
                mstore(0x60, m3)
    2138
                mstore(0x80, m4)
    2139
                mstore(0xa0, m5)
    2140
            }
    2141
        }
    2142
    
                                                    
                                                
    2143
        function log(uint256 p0, bytes32 p1, bool p2) internal pure {
    2144
            bytes32 m0;
    2145
            bytes32 m1;
    2146
            bytes32 m2;
    2147
            bytes32 m3;
    2148
            bytes32 m4;
    2149
            bytes32 m5;
    2150
            /// @solidity memory-safe-assembly
    2151
            assembly {
    2152
                function writeString(pos, w) {
    2153
                    let length := 0
    2154
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2155
                    mstore(pos, length)
    2156
                    let shift := sub(256, shl(3, length))
    2157
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2158
                }
    2159
                m0 := mload(0x00)
    2160
                m1 := mload(0x20)
    2161
                m2 := mload(0x40)
    2162
                m3 := mload(0x60)
    2163
                m4 := mload(0x80)
    2164
                m5 := mload(0xa0)
    2165
                // Selector of `log(uint256,string,bool)`.
    2166
                mstore(0x00, 0x4ceda75a)
    2167
                mstore(0x20, p0)
    2168
                mstore(0x40, 0x60)
    2169
                mstore(0x60, p2)
    2170
                writeString(0x80, p1)
    2171
            }
    2172
            _sendLogPayload(0x1c, 0xa4);
    2173
            /// @solidity memory-safe-assembly
    2174
            assembly {
    2175
                mstore(0x00, m0)
    2176
                mstore(0x20, m1)
    2177
                mstore(0x40, m2)
    2178
                mstore(0x60, m3)
    2179
                mstore(0x80, m4)
    2180
                mstore(0xa0, m5)
    2181
            }
    2182
        }
    2183
    
                                                    
                                                
    2184
        function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {
    2185
            bytes32 m0;
    2186
            bytes32 m1;
    2187
            bytes32 m2;
    2188
            bytes32 m3;
    2189
            bytes32 m4;
    2190
            bytes32 m5;
    2191
            /// @solidity memory-safe-assembly
    2192
            assembly {
    2193
                function writeString(pos, w) {
    2194
                    let length := 0
    2195
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2196
                    mstore(pos, length)
    2197
                    let shift := sub(256, shl(3, length))
    2198
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2199
                }
    2200
                m0 := mload(0x00)
    2201
                m1 := mload(0x20)
    2202
                m2 := mload(0x40)
    2203
                m3 := mload(0x60)
    2204
                m4 := mload(0x80)
    2205
                m5 := mload(0xa0)
    2206
                // Selector of `log(uint256,string,uint256)`.
    2207
                mstore(0x00, 0x37aa7d4c)
    2208
                mstore(0x20, p0)
    2209
                mstore(0x40, 0x60)
    2210
                mstore(0x60, p2)
    2211
                writeString(0x80, p1)
    2212
            }
    2213
            _sendLogPayload(0x1c, 0xa4);
    2214
            /// @solidity memory-safe-assembly
    2215
            assembly {
    2216
                mstore(0x00, m0)
    2217
                mstore(0x20, m1)
    2218
                mstore(0x40, m2)
    2219
                mstore(0x60, m3)
    2220
                mstore(0x80, m4)
    2221
                mstore(0xa0, m5)
    2222
            }
    2223
        }
    2224
    
                                                    
                                                
    2225
        function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {
    2226
            bytes32 m0;
    2227
            bytes32 m1;
    2228
            bytes32 m2;
    2229
            bytes32 m3;
    2230
            bytes32 m4;
    2231
            bytes32 m5;
    2232
            bytes32 m6;
    2233
            bytes32 m7;
    2234
            /// @solidity memory-safe-assembly
    2235
            assembly {
    2236
                function writeString(pos, w) {
    2237
                    let length := 0
    2238
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2239
                    mstore(pos, length)
    2240
                    let shift := sub(256, shl(3, length))
    2241
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2242
                }
    2243
                m0 := mload(0x00)
    2244
                m1 := mload(0x20)
    2245
                m2 := mload(0x40)
    2246
                m3 := mload(0x60)
    2247
                m4 := mload(0x80)
    2248
                m5 := mload(0xa0)
    2249
                m6 := mload(0xc0)
    2250
                m7 := mload(0xe0)
    2251
                // Selector of `log(uint256,string,string)`.
    2252
                mstore(0x00, 0xb115611f)
    2253
                mstore(0x20, p0)
    2254
                mstore(0x40, 0x60)
    2255
                mstore(0x60, 0xa0)
    2256
                writeString(0x80, p1)
    2257
                writeString(0xc0, p2)
    2258
            }
    2259
            _sendLogPayload(0x1c, 0xe4);
    2260
            /// @solidity memory-safe-assembly
    2261
            assembly {
    2262
                mstore(0x00, m0)
    2263
                mstore(0x20, m1)
    2264
                mstore(0x40, m2)
    2265
                mstore(0x60, m3)
    2266
                mstore(0x80, m4)
    2267
                mstore(0xa0, m5)
    2268
                mstore(0xc0, m6)
    2269
                mstore(0xe0, m7)
    2270
            }
    2271
        }
    2272
    
                                                    
                                                
    2273
        function log(bytes32 p0, address p1, address p2) internal pure {
    2274
            bytes32 m0;
    2275
            bytes32 m1;
    2276
            bytes32 m2;
    2277
            bytes32 m3;
    2278
            bytes32 m4;
    2279
            bytes32 m5;
    2280
            /// @solidity memory-safe-assembly
    2281
            assembly {
    2282
                function writeString(pos, w) {
    2283
                    let length := 0
    2284
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2285
                    mstore(pos, length)
    2286
                    let shift := sub(256, shl(3, length))
    2287
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2288
                }
    2289
                m0 := mload(0x00)
    2290
                m1 := mload(0x20)
    2291
                m2 := mload(0x40)
    2292
                m3 := mload(0x60)
    2293
                m4 := mload(0x80)
    2294
                m5 := mload(0xa0)
    2295
                // Selector of `log(string,address,address)`.
    2296
                mstore(0x00, 0xfcec75e0)
    2297
                mstore(0x20, 0x60)
    2298
                mstore(0x40, p1)
    2299
                mstore(0x60, p2)
    2300
                writeString(0x80, p0)
    2301
            }
    2302
            _sendLogPayload(0x1c, 0xa4);
    2303
            /// @solidity memory-safe-assembly
    2304
            assembly {
    2305
                mstore(0x00, m0)
    2306
                mstore(0x20, m1)
    2307
                mstore(0x40, m2)
    2308
                mstore(0x60, m3)
    2309
                mstore(0x80, m4)
    2310
                mstore(0xa0, m5)
    2311
            }
    2312
        }
    2313
    
                                                    
                                                
    2314
        function log(bytes32 p0, address p1, bool p2) internal pure {
    2315
            bytes32 m0;
    2316
            bytes32 m1;
    2317
            bytes32 m2;
    2318
            bytes32 m3;
    2319
            bytes32 m4;
    2320
            bytes32 m5;
    2321
            /// @solidity memory-safe-assembly
    2322
            assembly {
    2323
                function writeString(pos, w) {
    2324
                    let length := 0
    2325
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2326
                    mstore(pos, length)
    2327
                    let shift := sub(256, shl(3, length))
    2328
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2329
                }
    2330
                m0 := mload(0x00)
    2331
                m1 := mload(0x20)
    2332
                m2 := mload(0x40)
    2333
                m3 := mload(0x60)
    2334
                m4 := mload(0x80)
    2335
                m5 := mload(0xa0)
    2336
                // Selector of `log(string,address,bool)`.
    2337
                mstore(0x00, 0xc91d5ed4)
    2338
                mstore(0x20, 0x60)
    2339
                mstore(0x40, p1)
    2340
                mstore(0x60, p2)
    2341
                writeString(0x80, p0)
    2342
            }
    2343
            _sendLogPayload(0x1c, 0xa4);
    2344
            /// @solidity memory-safe-assembly
    2345
            assembly {
    2346
                mstore(0x00, m0)
    2347
                mstore(0x20, m1)
    2348
                mstore(0x40, m2)
    2349
                mstore(0x60, m3)
    2350
                mstore(0x80, m4)
    2351
                mstore(0xa0, m5)
    2352
            }
    2353
        }
    2354
    
                                                    
                                                
    2355
        function log(bytes32 p0, address p1, uint256 p2) internal pure {
    2356
            bytes32 m0;
    2357
            bytes32 m1;
    2358
            bytes32 m2;
    2359
            bytes32 m3;
    2360
            bytes32 m4;
    2361
            bytes32 m5;
    2362
            /// @solidity memory-safe-assembly
    2363
            assembly {
    2364
                function writeString(pos, w) {
    2365
                    let length := 0
    2366
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2367
                    mstore(pos, length)
    2368
                    let shift := sub(256, shl(3, length))
    2369
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2370
                }
    2371
                m0 := mload(0x00)
    2372
                m1 := mload(0x20)
    2373
                m2 := mload(0x40)
    2374
                m3 := mload(0x60)
    2375
                m4 := mload(0x80)
    2376
                m5 := mload(0xa0)
    2377
                // Selector of `log(string,address,uint256)`.
    2378
                mstore(0x00, 0x0d26b925)
    2379
                mstore(0x20, 0x60)
    2380
                mstore(0x40, p1)
    2381
                mstore(0x60, p2)
    2382
                writeString(0x80, p0)
    2383
            }
    2384
            _sendLogPayload(0x1c, 0xa4);
    2385
            /// @solidity memory-safe-assembly
    2386
            assembly {
    2387
                mstore(0x00, m0)
    2388
                mstore(0x20, m1)
    2389
                mstore(0x40, m2)
    2390
                mstore(0x60, m3)
    2391
                mstore(0x80, m4)
    2392
                mstore(0xa0, m5)
    2393
            }
    2394
        }
    2395
    
                                                    
                                                
    2396
        function log(bytes32 p0, address p1, bytes32 p2) internal pure {
    2397
            bytes32 m0;
    2398
            bytes32 m1;
    2399
            bytes32 m2;
    2400
            bytes32 m3;
    2401
            bytes32 m4;
    2402
            bytes32 m5;
    2403
            bytes32 m6;
    2404
            bytes32 m7;
    2405
            /// @solidity memory-safe-assembly
    2406
            assembly {
    2407
                function writeString(pos, w) {
    2408
                    let length := 0
    2409
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2410
                    mstore(pos, length)
    2411
                    let shift := sub(256, shl(3, length))
    2412
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2413
                }
    2414
                m0 := mload(0x00)
    2415
                m1 := mload(0x20)
    2416
                m2 := mload(0x40)
    2417
                m3 := mload(0x60)
    2418
                m4 := mload(0x80)
    2419
                m5 := mload(0xa0)
    2420
                m6 := mload(0xc0)
    2421
                m7 := mload(0xe0)
    2422
                // Selector of `log(string,address,string)`.
    2423
                mstore(0x00, 0xe0e9ad4f)
    2424
                mstore(0x20, 0x60)
    2425
                mstore(0x40, p1)
    2426
                mstore(0x60, 0xa0)
    2427
                writeString(0x80, p0)
    2428
                writeString(0xc0, p2)
    2429
            }
    2430
            _sendLogPayload(0x1c, 0xe4);
    2431
            /// @solidity memory-safe-assembly
    2432
            assembly {
    2433
                mstore(0x00, m0)
    2434
                mstore(0x20, m1)
    2435
                mstore(0x40, m2)
    2436
                mstore(0x60, m3)
    2437
                mstore(0x80, m4)
    2438
                mstore(0xa0, m5)
    2439
                mstore(0xc0, m6)
    2440
                mstore(0xe0, m7)
    2441
            }
    2442
        }
    2443
    
                                                    
                                                
    2444
        function log(bytes32 p0, bool p1, address p2) internal pure {
    2445
            bytes32 m0;
    2446
            bytes32 m1;
    2447
            bytes32 m2;
    2448
            bytes32 m3;
    2449
            bytes32 m4;
    2450
            bytes32 m5;
    2451
            /// @solidity memory-safe-assembly
    2452
            assembly {
    2453
                function writeString(pos, w) {
    2454
                    let length := 0
    2455
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2456
                    mstore(pos, length)
    2457
                    let shift := sub(256, shl(3, length))
    2458
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2459
                }
    2460
                m0 := mload(0x00)
    2461
                m1 := mload(0x20)
    2462
                m2 := mload(0x40)
    2463
                m3 := mload(0x60)
    2464
                m4 := mload(0x80)
    2465
                m5 := mload(0xa0)
    2466
                // Selector of `log(string,bool,address)`.
    2467
                mstore(0x00, 0x932bbb38)
    2468
                mstore(0x20, 0x60)
    2469
                mstore(0x40, p1)
    2470
                mstore(0x60, p2)
    2471
                writeString(0x80, p0)
    2472
            }
    2473
            _sendLogPayload(0x1c, 0xa4);
    2474
            /// @solidity memory-safe-assembly
    2475
            assembly {
    2476
                mstore(0x00, m0)
    2477
                mstore(0x20, m1)
    2478
                mstore(0x40, m2)
    2479
                mstore(0x60, m3)
    2480
                mstore(0x80, m4)
    2481
                mstore(0xa0, m5)
    2482
            }
    2483
        }
    2484
    
                                                    
                                                
    2485
        function log(bytes32 p0, bool p1, bool p2) internal pure {
    2486
            bytes32 m0;
    2487
            bytes32 m1;
    2488
            bytes32 m2;
    2489
            bytes32 m3;
    2490
            bytes32 m4;
    2491
            bytes32 m5;
    2492
            /// @solidity memory-safe-assembly
    2493
            assembly {
    2494
                function writeString(pos, w) {
    2495
                    let length := 0
    2496
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2497
                    mstore(pos, length)
    2498
                    let shift := sub(256, shl(3, length))
    2499
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2500
                }
    2501
                m0 := mload(0x00)
    2502
                m1 := mload(0x20)
    2503
                m2 := mload(0x40)
    2504
                m3 := mload(0x60)
    2505
                m4 := mload(0x80)
    2506
                m5 := mload(0xa0)
    2507
                // Selector of `log(string,bool,bool)`.
    2508
                mstore(0x00, 0x850b7ad6)
    2509
                mstore(0x20, 0x60)
    2510
                mstore(0x40, p1)
    2511
                mstore(0x60, p2)
    2512
                writeString(0x80, p0)
    2513
            }
    2514
            _sendLogPayload(0x1c, 0xa4);
    2515
            /// @solidity memory-safe-assembly
    2516
            assembly {
    2517
                mstore(0x00, m0)
    2518
                mstore(0x20, m1)
    2519
                mstore(0x40, m2)
    2520
                mstore(0x60, m3)
    2521
                mstore(0x80, m4)
    2522
                mstore(0xa0, m5)
    2523
            }
    2524
        }
    2525
    
                                                    
                                                
    2526
        function log(bytes32 p0, bool p1, uint256 p2) internal pure {
    2527
            bytes32 m0;
    2528
            bytes32 m1;
    2529
            bytes32 m2;
    2530
            bytes32 m3;
    2531
            bytes32 m4;
    2532
            bytes32 m5;
    2533
            /// @solidity memory-safe-assembly
    2534
            assembly {
    2535
                function writeString(pos, w) {
    2536
                    let length := 0
    2537
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2538
                    mstore(pos, length)
    2539
                    let shift := sub(256, shl(3, length))
    2540
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2541
                }
    2542
                m0 := mload(0x00)
    2543
                m1 := mload(0x20)
    2544
                m2 := mload(0x40)
    2545
                m3 := mload(0x60)
    2546
                m4 := mload(0x80)
    2547
                m5 := mload(0xa0)
    2548
                // Selector of `log(string,bool,uint256)`.
    2549
                mstore(0x00, 0xc95958d6)
    2550
                mstore(0x20, 0x60)
    2551
                mstore(0x40, p1)
    2552
                mstore(0x60, p2)
    2553
                writeString(0x80, p0)
    2554
            }
    2555
            _sendLogPayload(0x1c, 0xa4);
    2556
            /// @solidity memory-safe-assembly
    2557
            assembly {
    2558
                mstore(0x00, m0)
    2559
                mstore(0x20, m1)
    2560
                mstore(0x40, m2)
    2561
                mstore(0x60, m3)
    2562
                mstore(0x80, m4)
    2563
                mstore(0xa0, m5)
    2564
            }
    2565
        }
    2566
    
                                                    
                                                
    2567
        function log(bytes32 p0, bool p1, bytes32 p2) internal pure {
    2568
            bytes32 m0;
    2569
            bytes32 m1;
    2570
            bytes32 m2;
    2571
            bytes32 m3;
    2572
            bytes32 m4;
    2573
            bytes32 m5;
    2574
            bytes32 m6;
    2575
            bytes32 m7;
    2576
            /// @solidity memory-safe-assembly
    2577
            assembly {
    2578
                function writeString(pos, w) {
    2579
                    let length := 0
    2580
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2581
                    mstore(pos, length)
    2582
                    let shift := sub(256, shl(3, length))
    2583
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2584
                }
    2585
                m0 := mload(0x00)
    2586
                m1 := mload(0x20)
    2587
                m2 := mload(0x40)
    2588
                m3 := mload(0x60)
    2589
                m4 := mload(0x80)
    2590
                m5 := mload(0xa0)
    2591
                m6 := mload(0xc0)
    2592
                m7 := mload(0xe0)
    2593
                // Selector of `log(string,bool,string)`.
    2594
                mstore(0x00, 0xe298f47d)
    2595
                mstore(0x20, 0x60)
    2596
                mstore(0x40, p1)
    2597
                mstore(0x60, 0xa0)
    2598
                writeString(0x80, p0)
    2599
                writeString(0xc0, p2)
    2600
            }
    2601
            _sendLogPayload(0x1c, 0xe4);
    2602
            /// @solidity memory-safe-assembly
    2603
            assembly {
    2604
                mstore(0x00, m0)
    2605
                mstore(0x20, m1)
    2606
                mstore(0x40, m2)
    2607
                mstore(0x60, m3)
    2608
                mstore(0x80, m4)
    2609
                mstore(0xa0, m5)
    2610
                mstore(0xc0, m6)
    2611
                mstore(0xe0, m7)
    2612
            }
    2613
        }
    2614
    
                                                    
                                                
    2615
        function log(bytes32 p0, uint256 p1, address p2) internal pure {
    2616
            bytes32 m0;
    2617
            bytes32 m1;
    2618
            bytes32 m2;
    2619
            bytes32 m3;
    2620
            bytes32 m4;
    2621
            bytes32 m5;
    2622
            /// @solidity memory-safe-assembly
    2623
            assembly {
    2624
                function writeString(pos, w) {
    2625
                    let length := 0
    2626
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2627
                    mstore(pos, length)
    2628
                    let shift := sub(256, shl(3, length))
    2629
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2630
                }
    2631
                m0 := mload(0x00)
    2632
                m1 := mload(0x20)
    2633
                m2 := mload(0x40)
    2634
                m3 := mload(0x60)
    2635
                m4 := mload(0x80)
    2636
                m5 := mload(0xa0)
    2637
                // Selector of `log(string,uint256,address)`.
    2638
                mstore(0x00, 0x1c7ec448)
    2639
                mstore(0x20, 0x60)
    2640
                mstore(0x40, p1)
    2641
                mstore(0x60, p2)
    2642
                writeString(0x80, p0)
    2643
            }
    2644
            _sendLogPayload(0x1c, 0xa4);
    2645
            /// @solidity memory-safe-assembly
    2646
            assembly {
    2647
                mstore(0x00, m0)
    2648
                mstore(0x20, m1)
    2649
                mstore(0x40, m2)
    2650
                mstore(0x60, m3)
    2651
                mstore(0x80, m4)
    2652
                mstore(0xa0, m5)
    2653
            }
    2654
        }
    2655
    
                                                    
                                                
    2656
        function log(bytes32 p0, uint256 p1, bool p2) internal pure {
    2657
            bytes32 m0;
    2658
            bytes32 m1;
    2659
            bytes32 m2;
    2660
            bytes32 m3;
    2661
            bytes32 m4;
    2662
            bytes32 m5;
    2663
            /// @solidity memory-safe-assembly
    2664
            assembly {
    2665
                function writeString(pos, w) {
    2666
                    let length := 0
    2667
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2668
                    mstore(pos, length)
    2669
                    let shift := sub(256, shl(3, length))
    2670
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2671
                }
    2672
                m0 := mload(0x00)
    2673
                m1 := mload(0x20)
    2674
                m2 := mload(0x40)
    2675
                m3 := mload(0x60)
    2676
                m4 := mload(0x80)
    2677
                m5 := mload(0xa0)
    2678
                // Selector of `log(string,uint256,bool)`.
    2679
                mstore(0x00, 0xca7733b1)
    2680
                mstore(0x20, 0x60)
    2681
                mstore(0x40, p1)
    2682
                mstore(0x60, p2)
    2683
                writeString(0x80, p0)
    2684
            }
    2685
            _sendLogPayload(0x1c, 0xa4);
    2686
            /// @solidity memory-safe-assembly
    2687
            assembly {
    2688
                mstore(0x00, m0)
    2689
                mstore(0x20, m1)
    2690
                mstore(0x40, m2)
    2691
                mstore(0x60, m3)
    2692
                mstore(0x80, m4)
    2693
                mstore(0xa0, m5)
    2694
            }
    2695
        }
    2696
    
                                                    
                                                
    2697
        function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {
    2698
            bytes32 m0;
    2699
            bytes32 m1;
    2700
            bytes32 m2;
    2701
            bytes32 m3;
    2702
            bytes32 m4;
    2703
            bytes32 m5;
    2704
            /// @solidity memory-safe-assembly
    2705
            assembly {
    2706
                function writeString(pos, w) {
    2707
                    let length := 0
    2708
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2709
                    mstore(pos, length)
    2710
                    let shift := sub(256, shl(3, length))
    2711
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2712
                }
    2713
                m0 := mload(0x00)
    2714
                m1 := mload(0x20)
    2715
                m2 := mload(0x40)
    2716
                m3 := mload(0x60)
    2717
                m4 := mload(0x80)
    2718
                m5 := mload(0xa0)
    2719
                // Selector of `log(string,uint256,uint256)`.
    2720
                mstore(0x00, 0xca47c4eb)
    2721
                mstore(0x20, 0x60)
    2722
                mstore(0x40, p1)
    2723
                mstore(0x60, p2)
    2724
                writeString(0x80, p0)
    2725
            }
    2726
            _sendLogPayload(0x1c, 0xa4);
    2727
            /// @solidity memory-safe-assembly
    2728
            assembly {
    2729
                mstore(0x00, m0)
    2730
                mstore(0x20, m1)
    2731
                mstore(0x40, m2)
    2732
                mstore(0x60, m3)
    2733
                mstore(0x80, m4)
    2734
                mstore(0xa0, m5)
    2735
            }
    2736
        }
    2737
    
                                                    
                                                
    2738
        function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {
    2739
            bytes32 m0;
    2740
            bytes32 m1;
    2741
            bytes32 m2;
    2742
            bytes32 m3;
    2743
            bytes32 m4;
    2744
            bytes32 m5;
    2745
            bytes32 m6;
    2746
            bytes32 m7;
    2747
            /// @solidity memory-safe-assembly
    2748
            assembly {
    2749
                function writeString(pos, w) {
    2750
                    let length := 0
    2751
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2752
                    mstore(pos, length)
    2753
                    let shift := sub(256, shl(3, length))
    2754
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2755
                }
    2756
                m0 := mload(0x00)
    2757
                m1 := mload(0x20)
    2758
                m2 := mload(0x40)
    2759
                m3 := mload(0x60)
    2760
                m4 := mload(0x80)
    2761
                m5 := mload(0xa0)
    2762
                m6 := mload(0xc0)
    2763
                m7 := mload(0xe0)
    2764
                // Selector of `log(string,uint256,string)`.
    2765
                mstore(0x00, 0x5970e089)
    2766
                mstore(0x20, 0x60)
    2767
                mstore(0x40, p1)
    2768
                mstore(0x60, 0xa0)
    2769
                writeString(0x80, p0)
    2770
                writeString(0xc0, p2)
    2771
            }
    2772
            _sendLogPayload(0x1c, 0xe4);
    2773
            /// @solidity memory-safe-assembly
    2774
            assembly {
    2775
                mstore(0x00, m0)
    2776
                mstore(0x20, m1)
    2777
                mstore(0x40, m2)
    2778
                mstore(0x60, m3)
    2779
                mstore(0x80, m4)
    2780
                mstore(0xa0, m5)
    2781
                mstore(0xc0, m6)
    2782
                mstore(0xe0, m7)
    2783
            }
    2784
        }
    2785
    
                                                    
                                                
    2786
        function log(bytes32 p0, bytes32 p1, address p2) internal pure {
    2787
            bytes32 m0;
    2788
            bytes32 m1;
    2789
            bytes32 m2;
    2790
            bytes32 m3;
    2791
            bytes32 m4;
    2792
            bytes32 m5;
    2793
            bytes32 m6;
    2794
            bytes32 m7;
    2795
            /// @solidity memory-safe-assembly
    2796
            assembly {
    2797
                function writeString(pos, w) {
    2798
                    let length := 0
    2799
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2800
                    mstore(pos, length)
    2801
                    let shift := sub(256, shl(3, length))
    2802
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2803
                }
    2804
                m0 := mload(0x00)
    2805
                m1 := mload(0x20)
    2806
                m2 := mload(0x40)
    2807
                m3 := mload(0x60)
    2808
                m4 := mload(0x80)
    2809
                m5 := mload(0xa0)
    2810
                m6 := mload(0xc0)
    2811
                m7 := mload(0xe0)
    2812
                // Selector of `log(string,string,address)`.
    2813
                mstore(0x00, 0x95ed0195)
    2814
                mstore(0x20, 0x60)
    2815
                mstore(0x40, 0xa0)
    2816
                mstore(0x60, p2)
    2817
                writeString(0x80, p0)
    2818
                writeString(0xc0, p1)
    2819
            }
    2820
            _sendLogPayload(0x1c, 0xe4);
    2821
            /// @solidity memory-safe-assembly
    2822
            assembly {
    2823
                mstore(0x00, m0)
    2824
                mstore(0x20, m1)
    2825
                mstore(0x40, m2)
    2826
                mstore(0x60, m3)
    2827
                mstore(0x80, m4)
    2828
                mstore(0xa0, m5)
    2829
                mstore(0xc0, m6)
    2830
                mstore(0xe0, m7)
    2831
            }
    2832
        }
    2833
    
                                                    
                                                
    2834
        function log(bytes32 p0, bytes32 p1, bool p2) internal pure {
    2835
            bytes32 m0;
    2836
            bytes32 m1;
    2837
            bytes32 m2;
    2838
            bytes32 m3;
    2839
            bytes32 m4;
    2840
            bytes32 m5;
    2841
            bytes32 m6;
    2842
            bytes32 m7;
    2843
            /// @solidity memory-safe-assembly
    2844
            assembly {
    2845
                function writeString(pos, w) {
    2846
                    let length := 0
    2847
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2848
                    mstore(pos, length)
    2849
                    let shift := sub(256, shl(3, length))
    2850
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2851
                }
    2852
                m0 := mload(0x00)
    2853
                m1 := mload(0x20)
    2854
                m2 := mload(0x40)
    2855
                m3 := mload(0x60)
    2856
                m4 := mload(0x80)
    2857
                m5 := mload(0xa0)
    2858
                m6 := mload(0xc0)
    2859
                m7 := mload(0xe0)
    2860
                // Selector of `log(string,string,bool)`.
    2861
                mstore(0x00, 0xb0e0f9b5)
    2862
                mstore(0x20, 0x60)
    2863
                mstore(0x40, 0xa0)
    2864
                mstore(0x60, p2)
    2865
                writeString(0x80, p0)
    2866
                writeString(0xc0, p1)
    2867
            }
    2868
            _sendLogPayload(0x1c, 0xe4);
    2869
            /// @solidity memory-safe-assembly
    2870
            assembly {
    2871
                mstore(0x00, m0)
    2872
                mstore(0x20, m1)
    2873
                mstore(0x40, m2)
    2874
                mstore(0x60, m3)
    2875
                mstore(0x80, m4)
    2876
                mstore(0xa0, m5)
    2877
                mstore(0xc0, m6)
    2878
                mstore(0xe0, m7)
    2879
            }
    2880
        }
    2881
    
                                                    
                                                
    2882
        function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {
    2883
            bytes32 m0;
    2884
            bytes32 m1;
    2885
            bytes32 m2;
    2886
            bytes32 m3;
    2887
            bytes32 m4;
    2888
            bytes32 m5;
    2889
            bytes32 m6;
    2890
            bytes32 m7;
    2891
            /// @solidity memory-safe-assembly
    2892
            assembly {
    2893
                function writeString(pos, w) {
    2894
                    let length := 0
    2895
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2896
                    mstore(pos, length)
    2897
                    let shift := sub(256, shl(3, length))
    2898
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2899
                }
    2900
                m0 := mload(0x00)
    2901
                m1 := mload(0x20)
    2902
                m2 := mload(0x40)
    2903
                m3 := mload(0x60)
    2904
                m4 := mload(0x80)
    2905
                m5 := mload(0xa0)
    2906
                m6 := mload(0xc0)
    2907
                m7 := mload(0xe0)
    2908
                // Selector of `log(string,string,uint256)`.
    2909
                mstore(0x00, 0x5821efa1)
    2910
                mstore(0x20, 0x60)
    2911
                mstore(0x40, 0xa0)
    2912
                mstore(0x60, p2)
    2913
                writeString(0x80, p0)
    2914
                writeString(0xc0, p1)
    2915
            }
    2916
            _sendLogPayload(0x1c, 0xe4);
    2917
            /// @solidity memory-safe-assembly
    2918
            assembly {
    2919
                mstore(0x00, m0)
    2920
                mstore(0x20, m1)
    2921
                mstore(0x40, m2)
    2922
                mstore(0x60, m3)
    2923
                mstore(0x80, m4)
    2924
                mstore(0xa0, m5)
    2925
                mstore(0xc0, m6)
    2926
                mstore(0xe0, m7)
    2927
            }
    2928
        }
    2929
    
                                                    
                                                
    2930
        function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {
    2931
            bytes32 m0;
    2932
            bytes32 m1;
    2933
            bytes32 m2;
    2934
            bytes32 m3;
    2935
            bytes32 m4;
    2936
            bytes32 m5;
    2937
            bytes32 m6;
    2938
            bytes32 m7;
    2939
            bytes32 m8;
    2940
            bytes32 m9;
    2941
            /// @solidity memory-safe-assembly
    2942
            assembly {
    2943
                function writeString(pos, w) {
    2944
                    let length := 0
    2945
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2946
                    mstore(pos, length)
    2947
                    let shift := sub(256, shl(3, length))
    2948
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2949
                }
    2950
                m0 := mload(0x00)
    2951
                m1 := mload(0x20)
    2952
                m2 := mload(0x40)
    2953
                m3 := mload(0x60)
    2954
                m4 := mload(0x80)
    2955
                m5 := mload(0xa0)
    2956
                m6 := mload(0xc0)
    2957
                m7 := mload(0xe0)
    2958
                m8 := mload(0x100)
    2959
                m9 := mload(0x120)
    2960
                // Selector of `log(string,string,string)`.
    2961
                mstore(0x00, 0x2ced7cef)
    2962
                mstore(0x20, 0x60)
    2963
                mstore(0x40, 0xa0)
    2964
                mstore(0x60, 0xe0)
    2965
                writeString(0x80, p0)
    2966
                writeString(0xc0, p1)
    2967
                writeString(0x100, p2)
    2968
            }
    2969
            _sendLogPayload(0x1c, 0x124);
    2970
            /// @solidity memory-safe-assembly
    2971
            assembly {
    2972
                mstore(0x00, m0)
    2973
                mstore(0x20, m1)
    2974
                mstore(0x40, m2)
    2975
                mstore(0x60, m3)
    2976
                mstore(0x80, m4)
    2977
                mstore(0xa0, m5)
    2978
                mstore(0xc0, m6)
    2979
                mstore(0xe0, m7)
    2980
                mstore(0x100, m8)
    2981
                mstore(0x120, m9)
    2982
            }
    2983
        }
    2984
    
                                                    
                                                
    2985
        function log(address p0, address p1, address p2, address p3) internal pure {
    2986
            bytes32 m0;
    2987
            bytes32 m1;
    2988
            bytes32 m2;
    2989
            bytes32 m3;
    2990
            bytes32 m4;
    2991
            /// @solidity memory-safe-assembly
    2992
            assembly {
    2993
                m0 := mload(0x00)
    2994
                m1 := mload(0x20)
    2995
                m2 := mload(0x40)
    2996
                m3 := mload(0x60)
    2997
                m4 := mload(0x80)
    2998
                // Selector of `log(address,address,address,address)`.
    2999
                mstore(0x00, 0x665bf134)
    3000
                mstore(0x20, p0)
    3001
                mstore(0x40, p1)
    3002
                mstore(0x60, p2)
    3003
                mstore(0x80, p3)
    3004
            }
    3005
            _sendLogPayload(0x1c, 0x84);
    3006
            /// @solidity memory-safe-assembly
    3007
            assembly {
    3008
                mstore(0x00, m0)
    3009
                mstore(0x20, m1)
    3010
                mstore(0x40, m2)
    3011
                mstore(0x60, m3)
    3012
                mstore(0x80, m4)
    3013
            }
    3014
        }
    3015
    
                                                    
                                                
    3016
        function log(address p0, address p1, address p2, bool p3) internal pure {
    3017
            bytes32 m0;
    3018
            bytes32 m1;
    3019
            bytes32 m2;
    3020
            bytes32 m3;
    3021
            bytes32 m4;
    3022
            /// @solidity memory-safe-assembly
    3023
            assembly {
    3024
                m0 := mload(0x00)
    3025
                m1 := mload(0x20)
    3026
                m2 := mload(0x40)
    3027
                m3 := mload(0x60)
    3028
                m4 := mload(0x80)
    3029
                // Selector of `log(address,address,address,bool)`.
    3030
                mstore(0x00, 0x0e378994)
    3031
                mstore(0x20, p0)
    3032
                mstore(0x40, p1)
    3033
                mstore(0x60, p2)
    3034
                mstore(0x80, p3)
    3035
            }
    3036
            _sendLogPayload(0x1c, 0x84);
    3037
            /// @solidity memory-safe-assembly
    3038
            assembly {
    3039
                mstore(0x00, m0)
    3040
                mstore(0x20, m1)
    3041
                mstore(0x40, m2)
    3042
                mstore(0x60, m3)
    3043
                mstore(0x80, m4)
    3044
            }
    3045
        }
    3046
    
                                                    
                                                
    3047
        function log(address p0, address p1, address p2, uint256 p3) internal pure {
    3048
            bytes32 m0;
    3049
            bytes32 m1;
    3050
            bytes32 m2;
    3051
            bytes32 m3;
    3052
            bytes32 m4;
    3053
            /// @solidity memory-safe-assembly
    3054
            assembly {
    3055
                m0 := mload(0x00)
    3056
                m1 := mload(0x20)
    3057
                m2 := mload(0x40)
    3058
                m3 := mload(0x60)
    3059
                m4 := mload(0x80)
    3060
                // Selector of `log(address,address,address,uint256)`.
    3061
                mstore(0x00, 0x94250d77)
    3062
                mstore(0x20, p0)
    3063
                mstore(0x40, p1)
    3064
                mstore(0x60, p2)
    3065
                mstore(0x80, p3)
    3066
            }
    3067
            _sendLogPayload(0x1c, 0x84);
    3068
            /// @solidity memory-safe-assembly
    3069
            assembly {
    3070
                mstore(0x00, m0)
    3071
                mstore(0x20, m1)
    3072
                mstore(0x40, m2)
    3073
                mstore(0x60, m3)
    3074
                mstore(0x80, m4)
    3075
            }
    3076
        }
    3077
    
                                                    
                                                
    3078
        function log(address p0, address p1, address p2, bytes32 p3) internal pure {
    3079
            bytes32 m0;
    3080
            bytes32 m1;
    3081
            bytes32 m2;
    3082
            bytes32 m3;
    3083
            bytes32 m4;
    3084
            bytes32 m5;
    3085
            bytes32 m6;
    3086
            /// @solidity memory-safe-assembly
    3087
            assembly {
    3088
                function writeString(pos, w) {
    3089
                    let length := 0
    3090
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3091
                    mstore(pos, length)
    3092
                    let shift := sub(256, shl(3, length))
    3093
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3094
                }
    3095
                m0 := mload(0x00)
    3096
                m1 := mload(0x20)
    3097
                m2 := mload(0x40)
    3098
                m3 := mload(0x60)
    3099
                m4 := mload(0x80)
    3100
                m5 := mload(0xa0)
    3101
                m6 := mload(0xc0)
    3102
                // Selector of `log(address,address,address,string)`.
    3103
                mstore(0x00, 0xf808da20)
    3104
                mstore(0x20, p0)
    3105
                mstore(0x40, p1)
    3106
                mstore(0x60, p2)
    3107
                mstore(0x80, 0x80)
    3108
                writeString(0xa0, p3)
    3109
            }
    3110
            _sendLogPayload(0x1c, 0xc4);
    3111
            /// @solidity memory-safe-assembly
    3112
            assembly {
    3113
                mstore(0x00, m0)
    3114
                mstore(0x20, m1)
    3115
                mstore(0x40, m2)
    3116
                mstore(0x60, m3)
    3117
                mstore(0x80, m4)
    3118
                mstore(0xa0, m5)
    3119
                mstore(0xc0, m6)
    3120
            }
    3121
        }
    3122
    
                                                    
                                                
    3123
        function log(address p0, address p1, bool p2, address p3) internal pure {
    3124
            bytes32 m0;
    3125
            bytes32 m1;
    3126
            bytes32 m2;
    3127
            bytes32 m3;
    3128
            bytes32 m4;
    3129
            /// @solidity memory-safe-assembly
    3130
            assembly {
    3131
                m0 := mload(0x00)
    3132
                m1 := mload(0x20)
    3133
                m2 := mload(0x40)
    3134
                m3 := mload(0x60)
    3135
                m4 := mload(0x80)
    3136
                // Selector of `log(address,address,bool,address)`.
    3137
                mstore(0x00, 0x9f1bc36e)
    3138
                mstore(0x20, p0)
    3139
                mstore(0x40, p1)
    3140
                mstore(0x60, p2)
    3141
                mstore(0x80, p3)
    3142
            }
    3143
            _sendLogPayload(0x1c, 0x84);
    3144
            /// @solidity memory-safe-assembly
    3145
            assembly {
    3146
                mstore(0x00, m0)
    3147
                mstore(0x20, m1)
    3148
                mstore(0x40, m2)
    3149
                mstore(0x60, m3)
    3150
                mstore(0x80, m4)
    3151
            }
    3152
        }
    3153
    
                                                    
                                                
    3154
        function log(address p0, address p1, bool p2, bool p3) internal pure {
    3155
            bytes32 m0;
    3156
            bytes32 m1;
    3157
            bytes32 m2;
    3158
            bytes32 m3;
    3159
            bytes32 m4;
    3160
            /// @solidity memory-safe-assembly
    3161
            assembly {
    3162
                m0 := mload(0x00)
    3163
                m1 := mload(0x20)
    3164
                m2 := mload(0x40)
    3165
                m3 := mload(0x60)
    3166
                m4 := mload(0x80)
    3167
                // Selector of `log(address,address,bool,bool)`.
    3168
                mstore(0x00, 0x2cd4134a)
    3169
                mstore(0x20, p0)
    3170
                mstore(0x40, p1)
    3171
                mstore(0x60, p2)
    3172
                mstore(0x80, p3)
    3173
            }
    3174
            _sendLogPayload(0x1c, 0x84);
    3175
            /// @solidity memory-safe-assembly
    3176
            assembly {
    3177
                mstore(0x00, m0)
    3178
                mstore(0x20, m1)
    3179
                mstore(0x40, m2)
    3180
                mstore(0x60, m3)
    3181
                mstore(0x80, m4)
    3182
            }
    3183
        }
    3184
    
                                                    
                                                
    3185
        function log(address p0, address p1, bool p2, uint256 p3) internal pure {
    3186
            bytes32 m0;
    3187
            bytes32 m1;
    3188
            bytes32 m2;
    3189
            bytes32 m3;
    3190
            bytes32 m4;
    3191
            /// @solidity memory-safe-assembly
    3192
            assembly {
    3193
                m0 := mload(0x00)
    3194
                m1 := mload(0x20)
    3195
                m2 := mload(0x40)
    3196
                m3 := mload(0x60)
    3197
                m4 := mload(0x80)
    3198
                // Selector of `log(address,address,bool,uint256)`.
    3199
                mstore(0x00, 0x3971e78c)
    3200
                mstore(0x20, p0)
    3201
                mstore(0x40, p1)
    3202
                mstore(0x60, p2)
    3203
                mstore(0x80, p3)
    3204
            }
    3205
            _sendLogPayload(0x1c, 0x84);
    3206
            /// @solidity memory-safe-assembly
    3207
            assembly {
    3208
                mstore(0x00, m0)
    3209
                mstore(0x20, m1)
    3210
                mstore(0x40, m2)
    3211
                mstore(0x60, m3)
    3212
                mstore(0x80, m4)
    3213
            }
    3214
        }
    3215
    
                                                    
                                                
    3216
        function log(address p0, address p1, bool p2, bytes32 p3) internal pure {
    3217
            bytes32 m0;
    3218
            bytes32 m1;
    3219
            bytes32 m2;
    3220
            bytes32 m3;
    3221
            bytes32 m4;
    3222
            bytes32 m5;
    3223
            bytes32 m6;
    3224
            /// @solidity memory-safe-assembly
    3225
            assembly {
    3226
                function writeString(pos, w) {
    3227
                    let length := 0
    3228
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3229
                    mstore(pos, length)
    3230
                    let shift := sub(256, shl(3, length))
    3231
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3232
                }
    3233
                m0 := mload(0x00)
    3234
                m1 := mload(0x20)
    3235
                m2 := mload(0x40)
    3236
                m3 := mload(0x60)
    3237
                m4 := mload(0x80)
    3238
                m5 := mload(0xa0)
    3239
                m6 := mload(0xc0)
    3240
                // Selector of `log(address,address,bool,string)`.
    3241
                mstore(0x00, 0xaa6540c8)
    3242
                mstore(0x20, p0)
    3243
                mstore(0x40, p1)
    3244
                mstore(0x60, p2)
    3245
                mstore(0x80, 0x80)
    3246
                writeString(0xa0, p3)
    3247
            }
    3248
            _sendLogPayload(0x1c, 0xc4);
    3249
            /// @solidity memory-safe-assembly
    3250
            assembly {
    3251
                mstore(0x00, m0)
    3252
                mstore(0x20, m1)
    3253
                mstore(0x40, m2)
    3254
                mstore(0x60, m3)
    3255
                mstore(0x80, m4)
    3256
                mstore(0xa0, m5)
    3257
                mstore(0xc0, m6)
    3258
            }
    3259
        }
    3260
    
                                                    
                                                
    3261
        function log(address p0, address p1, uint256 p2, address p3) internal pure {
    3262
            bytes32 m0;
    3263
            bytes32 m1;
    3264
            bytes32 m2;
    3265
            bytes32 m3;
    3266
            bytes32 m4;
    3267
            /// @solidity memory-safe-assembly
    3268
            assembly {
    3269
                m0 := mload(0x00)
    3270
                m1 := mload(0x20)
    3271
                m2 := mload(0x40)
    3272
                m3 := mload(0x60)
    3273
                m4 := mload(0x80)
    3274
                // Selector of `log(address,address,uint256,address)`.
    3275
                mstore(0x00, 0x8da6def5)
    3276
                mstore(0x20, p0)
    3277
                mstore(0x40, p1)
    3278
                mstore(0x60, p2)
    3279
                mstore(0x80, p3)
    3280
            }
    3281
            _sendLogPayload(0x1c, 0x84);
    3282
            /// @solidity memory-safe-assembly
    3283
            assembly {
    3284
                mstore(0x00, m0)
    3285
                mstore(0x20, m1)
    3286
                mstore(0x40, m2)
    3287
                mstore(0x60, m3)
    3288
                mstore(0x80, m4)
    3289
            }
    3290
        }
    3291
    
                                                    
                                                
    3292
        function log(address p0, address p1, uint256 p2, bool p3) internal pure {
    3293
            bytes32 m0;
    3294
            bytes32 m1;
    3295
            bytes32 m2;
    3296
            bytes32 m3;
    3297
            bytes32 m4;
    3298
            /// @solidity memory-safe-assembly
    3299
            assembly {
    3300
                m0 := mload(0x00)
    3301
                m1 := mload(0x20)
    3302
                m2 := mload(0x40)
    3303
                m3 := mload(0x60)
    3304
                m4 := mload(0x80)
    3305
                // Selector of `log(address,address,uint256,bool)`.
    3306
                mstore(0x00, 0x9b4254e2)
    3307
                mstore(0x20, p0)
    3308
                mstore(0x40, p1)
    3309
                mstore(0x60, p2)
    3310
                mstore(0x80, p3)
    3311
            }
    3312
            _sendLogPayload(0x1c, 0x84);
    3313
            /// @solidity memory-safe-assembly
    3314
            assembly {
    3315
                mstore(0x00, m0)
    3316
                mstore(0x20, m1)
    3317
                mstore(0x40, m2)
    3318
                mstore(0x60, m3)
    3319
                mstore(0x80, m4)
    3320
            }
    3321
        }
    3322
    
                                                    
                                                
    3323
        function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
    3324
            bytes32 m0;
    3325
            bytes32 m1;
    3326
            bytes32 m2;
    3327
            bytes32 m3;
    3328
            bytes32 m4;
    3329
            /// @solidity memory-safe-assembly
    3330
            assembly {
    3331
                m0 := mload(0x00)
    3332
                m1 := mload(0x20)
    3333
                m2 := mload(0x40)
    3334
                m3 := mload(0x60)
    3335
                m4 := mload(0x80)
    3336
                // Selector of `log(address,address,uint256,uint256)`.
    3337
                mstore(0x00, 0xbe553481)
    3338
                mstore(0x20, p0)
    3339
                mstore(0x40, p1)
    3340
                mstore(0x60, p2)
    3341
                mstore(0x80, p3)
    3342
            }
    3343
            _sendLogPayload(0x1c, 0x84);
    3344
            /// @solidity memory-safe-assembly
    3345
            assembly {
    3346
                mstore(0x00, m0)
    3347
                mstore(0x20, m1)
    3348
                mstore(0x40, m2)
    3349
                mstore(0x60, m3)
    3350
                mstore(0x80, m4)
    3351
            }
    3352
        }
    3353
    
                                                    
                                                
    3354
        function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {
    3355
            bytes32 m0;
    3356
            bytes32 m1;
    3357
            bytes32 m2;
    3358
            bytes32 m3;
    3359
            bytes32 m4;
    3360
            bytes32 m5;
    3361
            bytes32 m6;
    3362
            /// @solidity memory-safe-assembly
    3363
            assembly {
    3364
                function writeString(pos, w) {
    3365
                    let length := 0
    3366
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3367
                    mstore(pos, length)
    3368
                    let shift := sub(256, shl(3, length))
    3369
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3370
                }
    3371
                m0 := mload(0x00)
    3372
                m1 := mload(0x20)
    3373
                m2 := mload(0x40)
    3374
                m3 := mload(0x60)
    3375
                m4 := mload(0x80)
    3376
                m5 := mload(0xa0)
    3377
                m6 := mload(0xc0)
    3378
                // Selector of `log(address,address,uint256,string)`.
    3379
                mstore(0x00, 0xfdb4f990)
    3380
                mstore(0x20, p0)
    3381
                mstore(0x40, p1)
    3382
                mstore(0x60, p2)
    3383
                mstore(0x80, 0x80)
    3384
                writeString(0xa0, p3)
    3385
            }
    3386
            _sendLogPayload(0x1c, 0xc4);
    3387
            /// @solidity memory-safe-assembly
    3388
            assembly {
    3389
                mstore(0x00, m0)
    3390
                mstore(0x20, m1)
    3391
                mstore(0x40, m2)
    3392
                mstore(0x60, m3)
    3393
                mstore(0x80, m4)
    3394
                mstore(0xa0, m5)
    3395
                mstore(0xc0, m6)
    3396
            }
    3397
        }
    3398
    
                                                    
                                                
    3399
        function log(address p0, address p1, bytes32 p2, address p3) internal pure {
    3400
            bytes32 m0;
    3401
            bytes32 m1;
    3402
            bytes32 m2;
    3403
            bytes32 m3;
    3404
            bytes32 m4;
    3405
            bytes32 m5;
    3406
            bytes32 m6;
    3407
            /// @solidity memory-safe-assembly
    3408
            assembly {
    3409
                function writeString(pos, w) {
    3410
                    let length := 0
    3411
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3412
                    mstore(pos, length)
    3413
                    let shift := sub(256, shl(3, length))
    3414
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3415
                }
    3416
                m0 := mload(0x00)
    3417
                m1 := mload(0x20)
    3418
                m2 := mload(0x40)
    3419
                m3 := mload(0x60)
    3420
                m4 := mload(0x80)
    3421
                m5 := mload(0xa0)
    3422
                m6 := mload(0xc0)
    3423
                // Selector of `log(address,address,string,address)`.
    3424
                mstore(0x00, 0x8f736d16)
    3425
                mstore(0x20, p0)
    3426
                mstore(0x40, p1)
    3427
                mstore(0x60, 0x80)
    3428
                mstore(0x80, p3)
    3429
                writeString(0xa0, p2)
    3430
            }
    3431
            _sendLogPayload(0x1c, 0xc4);
    3432
            /// @solidity memory-safe-assembly
    3433
            assembly {
    3434
                mstore(0x00, m0)
    3435
                mstore(0x20, m1)
    3436
                mstore(0x40, m2)
    3437
                mstore(0x60, m3)
    3438
                mstore(0x80, m4)
    3439
                mstore(0xa0, m5)
    3440
                mstore(0xc0, m6)
    3441
            }
    3442
        }
    3443
    
                                                    
                                                
    3444
        function log(address p0, address p1, bytes32 p2, bool p3) internal pure {
    3445
            bytes32 m0;
    3446
            bytes32 m1;
    3447
            bytes32 m2;
    3448
            bytes32 m3;
    3449
            bytes32 m4;
    3450
            bytes32 m5;
    3451
            bytes32 m6;
    3452
            /// @solidity memory-safe-assembly
    3453
            assembly {
    3454
                function writeString(pos, w) {
    3455
                    let length := 0
    3456
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3457
                    mstore(pos, length)
    3458
                    let shift := sub(256, shl(3, length))
    3459
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3460
                }
    3461
                m0 := mload(0x00)
    3462
                m1 := mload(0x20)
    3463
                m2 := mload(0x40)
    3464
                m3 := mload(0x60)
    3465
                m4 := mload(0x80)
    3466
                m5 := mload(0xa0)
    3467
                m6 := mload(0xc0)
    3468
                // Selector of `log(address,address,string,bool)`.
    3469
                mstore(0x00, 0x6f1a594e)
    3470
                mstore(0x20, p0)
    3471
                mstore(0x40, p1)
    3472
                mstore(0x60, 0x80)
    3473
                mstore(0x80, p3)
    3474
                writeString(0xa0, p2)
    3475
            }
    3476
            _sendLogPayload(0x1c, 0xc4);
    3477
            /// @solidity memory-safe-assembly
    3478
            assembly {
    3479
                mstore(0x00, m0)
    3480
                mstore(0x20, m1)
    3481
                mstore(0x40, m2)
    3482
                mstore(0x60, m3)
    3483
                mstore(0x80, m4)
    3484
                mstore(0xa0, m5)
    3485
                mstore(0xc0, m6)
    3486
            }
    3487
        }
    3488
    
                                                    
                                                
    3489
        function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {
    3490
            bytes32 m0;
    3491
            bytes32 m1;
    3492
            bytes32 m2;
    3493
            bytes32 m3;
    3494
            bytes32 m4;
    3495
            bytes32 m5;
    3496
            bytes32 m6;
    3497
            /// @solidity memory-safe-assembly
    3498
            assembly {
    3499
                function writeString(pos, w) {
    3500
                    let length := 0
    3501
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3502
                    mstore(pos, length)
    3503
                    let shift := sub(256, shl(3, length))
    3504
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3505
                }
    3506
                m0 := mload(0x00)
    3507
                m1 := mload(0x20)
    3508
                m2 := mload(0x40)
    3509
                m3 := mload(0x60)
    3510
                m4 := mload(0x80)
    3511
                m5 := mload(0xa0)
    3512
                m6 := mload(0xc0)
    3513
                // Selector of `log(address,address,string,uint256)`.
    3514
                mstore(0x00, 0xef1cefe7)
    3515
                mstore(0x20, p0)
    3516
                mstore(0x40, p1)
    3517
                mstore(0x60, 0x80)
    3518
                mstore(0x80, p3)
    3519
                writeString(0xa0, p2)
    3520
            }
    3521
            _sendLogPayload(0x1c, 0xc4);
    3522
            /// @solidity memory-safe-assembly
    3523
            assembly {
    3524
                mstore(0x00, m0)
    3525
                mstore(0x20, m1)
    3526
                mstore(0x40, m2)
    3527
                mstore(0x60, m3)
    3528
                mstore(0x80, m4)
    3529
                mstore(0xa0, m5)
    3530
                mstore(0xc0, m6)
    3531
            }
    3532
        }
    3533
    
                                                    
                                                
    3534
        function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    3535
            bytes32 m0;
    3536
            bytes32 m1;
    3537
            bytes32 m2;
    3538
            bytes32 m3;
    3539
            bytes32 m4;
    3540
            bytes32 m5;
    3541
            bytes32 m6;
    3542
            bytes32 m7;
    3543
            bytes32 m8;
    3544
            /// @solidity memory-safe-assembly
    3545
            assembly {
    3546
                function writeString(pos, w) {
    3547
                    let length := 0
    3548
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3549
                    mstore(pos, length)
    3550
                    let shift := sub(256, shl(3, length))
    3551
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3552
                }
    3553
                m0 := mload(0x00)
    3554
                m1 := mload(0x20)
    3555
                m2 := mload(0x40)
    3556
                m3 := mload(0x60)
    3557
                m4 := mload(0x80)
    3558
                m5 := mload(0xa0)
    3559
                m6 := mload(0xc0)
    3560
                m7 := mload(0xe0)
    3561
                m8 := mload(0x100)
    3562
                // Selector of `log(address,address,string,string)`.
    3563
                mstore(0x00, 0x21bdaf25)
    3564
                mstore(0x20, p0)
    3565
                mstore(0x40, p1)
    3566
                mstore(0x60, 0x80)
    3567
                mstore(0x80, 0xc0)
    3568
                writeString(0xa0, p2)
    3569
                writeString(0xe0, p3)
    3570
            }
    3571
            _sendLogPayload(0x1c, 0x104);
    3572
            /// @solidity memory-safe-assembly
    3573
            assembly {
    3574
                mstore(0x00, m0)
    3575
                mstore(0x20, m1)
    3576
                mstore(0x40, m2)
    3577
                mstore(0x60, m3)
    3578
                mstore(0x80, m4)
    3579
                mstore(0xa0, m5)
    3580
                mstore(0xc0, m6)
    3581
                mstore(0xe0, m7)
    3582
                mstore(0x100, m8)
    3583
            }
    3584
        }
    3585
    
                                                    
                                                
    3586
        function log(address p0, bool p1, address p2, address p3) internal pure {
    3587
            bytes32 m0;
    3588
            bytes32 m1;
    3589
            bytes32 m2;
    3590
            bytes32 m3;
    3591
            bytes32 m4;
    3592
            /// @solidity memory-safe-assembly
    3593
            assembly {
    3594
                m0 := mload(0x00)
    3595
                m1 := mload(0x20)
    3596
                m2 := mload(0x40)
    3597
                m3 := mload(0x60)
    3598
                m4 := mload(0x80)
    3599
                // Selector of `log(address,bool,address,address)`.
    3600
                mstore(0x00, 0x660375dd)
    3601
                mstore(0x20, p0)
    3602
                mstore(0x40, p1)
    3603
                mstore(0x60, p2)
    3604
                mstore(0x80, p3)
    3605
            }
    3606
            _sendLogPayload(0x1c, 0x84);
    3607
            /// @solidity memory-safe-assembly
    3608
            assembly {
    3609
                mstore(0x00, m0)
    3610
                mstore(0x20, m1)
    3611
                mstore(0x40, m2)
    3612
                mstore(0x60, m3)
    3613
                mstore(0x80, m4)
    3614
            }
    3615
        }
    3616
    
                                                    
                                                
    3617
        function log(address p0, bool p1, address p2, bool p3) internal pure {
    3618
            bytes32 m0;
    3619
            bytes32 m1;
    3620
            bytes32 m2;
    3621
            bytes32 m3;
    3622
            bytes32 m4;
    3623
            /// @solidity memory-safe-assembly
    3624
            assembly {
    3625
                m0 := mload(0x00)
    3626
                m1 := mload(0x20)
    3627
                m2 := mload(0x40)
    3628
                m3 := mload(0x60)
    3629
                m4 := mload(0x80)
    3630
                // Selector of `log(address,bool,address,bool)`.
    3631
                mstore(0x00, 0xa6f50b0f)
    3632
                mstore(0x20, p0)
    3633
                mstore(0x40, p1)
    3634
                mstore(0x60, p2)
    3635
                mstore(0x80, p3)
    3636
            }
    3637
            _sendLogPayload(0x1c, 0x84);
    3638
            /// @solidity memory-safe-assembly
    3639
            assembly {
    3640
                mstore(0x00, m0)
    3641
                mstore(0x20, m1)
    3642
                mstore(0x40, m2)
    3643
                mstore(0x60, m3)
    3644
                mstore(0x80, m4)
    3645
            }
    3646
        }
    3647
    
                                                    
                                                
    3648
        function log(address p0, bool p1, address p2, uint256 p3) internal pure {
    3649
            bytes32 m0;
    3650
            bytes32 m1;
    3651
            bytes32 m2;
    3652
            bytes32 m3;
    3653
            bytes32 m4;
    3654
            /// @solidity memory-safe-assembly
    3655
            assembly {
    3656
                m0 := mload(0x00)
    3657
                m1 := mload(0x20)
    3658
                m2 := mload(0x40)
    3659
                m3 := mload(0x60)
    3660
                m4 := mload(0x80)
    3661
                // Selector of `log(address,bool,address,uint256)`.
    3662
                mstore(0x00, 0xa75c59de)
    3663
                mstore(0x20, p0)
    3664
                mstore(0x40, p1)
    3665
                mstore(0x60, p2)
    3666
                mstore(0x80, p3)
    3667
            }
    3668
            _sendLogPayload(0x1c, 0x84);
    3669
            /// @solidity memory-safe-assembly
    3670
            assembly {
    3671
                mstore(0x00, m0)
    3672
                mstore(0x20, m1)
    3673
                mstore(0x40, m2)
    3674
                mstore(0x60, m3)
    3675
                mstore(0x80, m4)
    3676
            }
    3677
        }
    3678
    
                                                    
                                                
    3679
        function log(address p0, bool p1, address p2, bytes32 p3) internal pure {
    3680
            bytes32 m0;
    3681
            bytes32 m1;
    3682
            bytes32 m2;
    3683
            bytes32 m3;
    3684
            bytes32 m4;
    3685
            bytes32 m5;
    3686
            bytes32 m6;
    3687
            /// @solidity memory-safe-assembly
    3688
            assembly {
    3689
                function writeString(pos, w) {
    3690
                    let length := 0
    3691
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3692
                    mstore(pos, length)
    3693
                    let shift := sub(256, shl(3, length))
    3694
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3695
                }
    3696
                m0 := mload(0x00)
    3697
                m1 := mload(0x20)
    3698
                m2 := mload(0x40)
    3699
                m3 := mload(0x60)
    3700
                m4 := mload(0x80)
    3701
                m5 := mload(0xa0)
    3702
                m6 := mload(0xc0)
    3703
                // Selector of `log(address,bool,address,string)`.
    3704
                mstore(0x00, 0x2dd778e6)
    3705
                mstore(0x20, p0)
    3706
                mstore(0x40, p1)
    3707
                mstore(0x60, p2)
    3708
                mstore(0x80, 0x80)
    3709
                writeString(0xa0, p3)
    3710
            }
    3711
            _sendLogPayload(0x1c, 0xc4);
    3712
            /// @solidity memory-safe-assembly
    3713
            assembly {
    3714
                mstore(0x00, m0)
    3715
                mstore(0x20, m1)
    3716
                mstore(0x40, m2)
    3717
                mstore(0x60, m3)
    3718
                mstore(0x80, m4)
    3719
                mstore(0xa0, m5)
    3720
                mstore(0xc0, m6)
    3721
            }
    3722
        }
    3723
    
                                                    
                                                
    3724
        function log(address p0, bool p1, bool p2, address p3) internal pure {
    3725
            bytes32 m0;
    3726
            bytes32 m1;
    3727
            bytes32 m2;
    3728
            bytes32 m3;
    3729
            bytes32 m4;
    3730
            /// @solidity memory-safe-assembly
    3731
            assembly {
    3732
                m0 := mload(0x00)
    3733
                m1 := mload(0x20)
    3734
                m2 := mload(0x40)
    3735
                m3 := mload(0x60)
    3736
                m4 := mload(0x80)
    3737
                // Selector of `log(address,bool,bool,address)`.
    3738
                mstore(0x00, 0xcf394485)
    3739
                mstore(0x20, p0)
    3740
                mstore(0x40, p1)
    3741
                mstore(0x60, p2)
    3742
                mstore(0x80, p3)
    3743
            }
    3744
            _sendLogPayload(0x1c, 0x84);
    3745
            /// @solidity memory-safe-assembly
    3746
            assembly {
    3747
                mstore(0x00, m0)
    3748
                mstore(0x20, m1)
    3749
                mstore(0x40, m2)
    3750
                mstore(0x60, m3)
    3751
                mstore(0x80, m4)
    3752
            }
    3753
        }
    3754
    
                                                    
                                                
    3755
        function log(address p0, bool p1, bool p2, bool p3) internal pure {
    3756
            bytes32 m0;
    3757
            bytes32 m1;
    3758
            bytes32 m2;
    3759
            bytes32 m3;
    3760
            bytes32 m4;
    3761
            /// @solidity memory-safe-assembly
    3762
            assembly {
    3763
                m0 := mload(0x00)
    3764
                m1 := mload(0x20)
    3765
                m2 := mload(0x40)
    3766
                m3 := mload(0x60)
    3767
                m4 := mload(0x80)
    3768
                // Selector of `log(address,bool,bool,bool)`.
    3769
                mstore(0x00, 0xcac43479)
    3770
                mstore(0x20, p0)
    3771
                mstore(0x40, p1)
    3772
                mstore(0x60, p2)
    3773
                mstore(0x80, p3)
    3774
            }
    3775
            _sendLogPayload(0x1c, 0x84);
    3776
            /// @solidity memory-safe-assembly
    3777
            assembly {
    3778
                mstore(0x00, m0)
    3779
                mstore(0x20, m1)
    3780
                mstore(0x40, m2)
    3781
                mstore(0x60, m3)
    3782
                mstore(0x80, m4)
    3783
            }
    3784
        }
    3785
    
                                                    
                                                
    3786
        function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
    3787
            bytes32 m0;
    3788
            bytes32 m1;
    3789
            bytes32 m2;
    3790
            bytes32 m3;
    3791
            bytes32 m4;
    3792
            /// @solidity memory-safe-assembly
    3793
            assembly {
    3794
                m0 := mload(0x00)
    3795
                m1 := mload(0x20)
    3796
                m2 := mload(0x40)
    3797
                m3 := mload(0x60)
    3798
                m4 := mload(0x80)
    3799
                // Selector of `log(address,bool,bool,uint256)`.
    3800
                mstore(0x00, 0x8c4e5de6)
    3801
                mstore(0x20, p0)
    3802
                mstore(0x40, p1)
    3803
                mstore(0x60, p2)
    3804
                mstore(0x80, p3)
    3805
            }
    3806
            _sendLogPayload(0x1c, 0x84);
    3807
            /// @solidity memory-safe-assembly
    3808
            assembly {
    3809
                mstore(0x00, m0)
    3810
                mstore(0x20, m1)
    3811
                mstore(0x40, m2)
    3812
                mstore(0x60, m3)
    3813
                mstore(0x80, m4)
    3814
            }
    3815
        }
    3816
    
                                                    
                                                
    3817
        function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {
    3818
            bytes32 m0;
    3819
            bytes32 m1;
    3820
            bytes32 m2;
    3821
            bytes32 m3;
    3822
            bytes32 m4;
    3823
            bytes32 m5;
    3824
            bytes32 m6;
    3825
            /// @solidity memory-safe-assembly
    3826
            assembly {
    3827
                function writeString(pos, w) {
    3828
                    let length := 0
    3829
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3830
                    mstore(pos, length)
    3831
                    let shift := sub(256, shl(3, length))
    3832
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3833
                }
    3834
                m0 := mload(0x00)
    3835
                m1 := mload(0x20)
    3836
                m2 := mload(0x40)
    3837
                m3 := mload(0x60)
    3838
                m4 := mload(0x80)
    3839
                m5 := mload(0xa0)
    3840
                m6 := mload(0xc0)
    3841
                // Selector of `log(address,bool,bool,string)`.
    3842
                mstore(0x00, 0xdfc4a2e8)
    3843
                mstore(0x20, p0)
    3844
                mstore(0x40, p1)
    3845
                mstore(0x60, p2)
    3846
                mstore(0x80, 0x80)
    3847
                writeString(0xa0, p3)
    3848
            }
    3849
            _sendLogPayload(0x1c, 0xc4);
    3850
            /// @solidity memory-safe-assembly
    3851
            assembly {
    3852
                mstore(0x00, m0)
    3853
                mstore(0x20, m1)
    3854
                mstore(0x40, m2)
    3855
                mstore(0x60, m3)
    3856
                mstore(0x80, m4)
    3857
                mstore(0xa0, m5)
    3858
                mstore(0xc0, m6)
    3859
            }
    3860
        }
    3861
    
                                                    
                                                
    3862
        function log(address p0, bool p1, uint256 p2, address p3) internal pure {
    3863
            bytes32 m0;
    3864
            bytes32 m1;
    3865
            bytes32 m2;
    3866
            bytes32 m3;
    3867
            bytes32 m4;
    3868
            /// @solidity memory-safe-assembly
    3869
            assembly {
    3870
                m0 := mload(0x00)
    3871
                m1 := mload(0x20)
    3872
                m2 := mload(0x40)
    3873
                m3 := mload(0x60)
    3874
                m4 := mload(0x80)
    3875
                // Selector of `log(address,bool,uint256,address)`.
    3876
                mstore(0x00, 0xccf790a1)
    3877
                mstore(0x20, p0)
    3878
                mstore(0x40, p1)
    3879
                mstore(0x60, p2)
    3880
                mstore(0x80, p3)
    3881
            }
    3882
            _sendLogPayload(0x1c, 0x84);
    3883
            /// @solidity memory-safe-assembly
    3884
            assembly {
    3885
                mstore(0x00, m0)
    3886
                mstore(0x20, m1)
    3887
                mstore(0x40, m2)
    3888
                mstore(0x60, m3)
    3889
                mstore(0x80, m4)
    3890
            }
    3891
        }
    3892
    
                                                    
                                                
    3893
        function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
    3894
            bytes32 m0;
    3895
            bytes32 m1;
    3896
            bytes32 m2;
    3897
            bytes32 m3;
    3898
            bytes32 m4;
    3899
            /// @solidity memory-safe-assembly
    3900
            assembly {
    3901
                m0 := mload(0x00)
    3902
                m1 := mload(0x20)
    3903
                m2 := mload(0x40)
    3904
                m3 := mload(0x60)
    3905
                m4 := mload(0x80)
    3906
                // Selector of `log(address,bool,uint256,bool)`.
    3907
                mstore(0x00, 0xc4643e20)
    3908
                mstore(0x20, p0)
    3909
                mstore(0x40, p1)
    3910
                mstore(0x60, p2)
    3911
                mstore(0x80, p3)
    3912
            }
    3913
            _sendLogPayload(0x1c, 0x84);
    3914
            /// @solidity memory-safe-assembly
    3915
            assembly {
    3916
                mstore(0x00, m0)
    3917
                mstore(0x20, m1)
    3918
                mstore(0x40, m2)
    3919
                mstore(0x60, m3)
    3920
                mstore(0x80, m4)
    3921
            }
    3922
        }
    3923
    
                                                    
                                                
    3924
        function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
    3925
            bytes32 m0;
    3926
            bytes32 m1;
    3927
            bytes32 m2;
    3928
            bytes32 m3;
    3929
            bytes32 m4;
    3930
            /// @solidity memory-safe-assembly
    3931
            assembly {
    3932
                m0 := mload(0x00)
    3933
                m1 := mload(0x20)
    3934
                m2 := mload(0x40)
    3935
                m3 := mload(0x60)
    3936
                m4 := mload(0x80)
    3937
                // Selector of `log(address,bool,uint256,uint256)`.
    3938
                mstore(0x00, 0x386ff5f4)
    3939
                mstore(0x20, p0)
    3940
                mstore(0x40, p1)
    3941
                mstore(0x60, p2)
    3942
                mstore(0x80, p3)
    3943
            }
    3944
            _sendLogPayload(0x1c, 0x84);
    3945
            /// @solidity memory-safe-assembly
    3946
            assembly {
    3947
                mstore(0x00, m0)
    3948
                mstore(0x20, m1)
    3949
                mstore(0x40, m2)
    3950
                mstore(0x60, m3)
    3951
                mstore(0x80, m4)
    3952
            }
    3953
        }
    3954
    
                                                    
                                                
    3955
        function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    3956
            bytes32 m0;
    3957
            bytes32 m1;
    3958
            bytes32 m2;
    3959
            bytes32 m3;
    3960
            bytes32 m4;
    3961
            bytes32 m5;
    3962
            bytes32 m6;
    3963
            /// @solidity memory-safe-assembly
    3964
            assembly {
    3965
                function writeString(pos, w) {
    3966
                    let length := 0
    3967
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3968
                    mstore(pos, length)
    3969
                    let shift := sub(256, shl(3, length))
    3970
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3971
                }
    3972
                m0 := mload(0x00)
    3973
                m1 := mload(0x20)
    3974
                m2 := mload(0x40)
    3975
                m3 := mload(0x60)
    3976
                m4 := mload(0x80)
    3977
                m5 := mload(0xa0)
    3978
                m6 := mload(0xc0)
    3979
                // Selector of `log(address,bool,uint256,string)`.
    3980
                mstore(0x00, 0x0aa6cfad)
    3981
                mstore(0x20, p0)
    3982
                mstore(0x40, p1)
    3983
                mstore(0x60, p2)
    3984
                mstore(0x80, 0x80)
    3985
                writeString(0xa0, p3)
    3986
            }
    3987
            _sendLogPayload(0x1c, 0xc4);
    3988
            /// @solidity memory-safe-assembly
    3989
            assembly {
    3990
                mstore(0x00, m0)
    3991
                mstore(0x20, m1)
    3992
                mstore(0x40, m2)
    3993
                mstore(0x60, m3)
    3994
                mstore(0x80, m4)
    3995
                mstore(0xa0, m5)
    3996
                mstore(0xc0, m6)
    3997
            }
    3998
        }
    3999
    
                                                    
                                                
    4000
        function log(address p0, bool p1, bytes32 p2, address p3) internal pure {
    4001
            bytes32 m0;
    4002
            bytes32 m1;
    4003
            bytes32 m2;
    4004
            bytes32 m3;
    4005
            bytes32 m4;
    4006
            bytes32 m5;
    4007
            bytes32 m6;
    4008
            /// @solidity memory-safe-assembly
    4009
            assembly {
    4010
                function writeString(pos, w) {
    4011
                    let length := 0
    4012
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4013
                    mstore(pos, length)
    4014
                    let shift := sub(256, shl(3, length))
    4015
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4016
                }
    4017
                m0 := mload(0x00)
    4018
                m1 := mload(0x20)
    4019
                m2 := mload(0x40)
    4020
                m3 := mload(0x60)
    4021
                m4 := mload(0x80)
    4022
                m5 := mload(0xa0)
    4023
                m6 := mload(0xc0)
    4024
                // Selector of `log(address,bool,string,address)`.
    4025
                mstore(0x00, 0x19fd4956)
    4026
                mstore(0x20, p0)
    4027
                mstore(0x40, p1)
    4028
                mstore(0x60, 0x80)
    4029
                mstore(0x80, p3)
    4030
                writeString(0xa0, p2)
    4031
            }
    4032
            _sendLogPayload(0x1c, 0xc4);
    4033
            /// @solidity memory-safe-assembly
    4034
            assembly {
    4035
                mstore(0x00, m0)
    4036
                mstore(0x20, m1)
    4037
                mstore(0x40, m2)
    4038
                mstore(0x60, m3)
    4039
                mstore(0x80, m4)
    4040
                mstore(0xa0, m5)
    4041
                mstore(0xc0, m6)
    4042
            }
    4043
        }
    4044
    
                                                    
                                                
    4045
        function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {
    4046
            bytes32 m0;
    4047
            bytes32 m1;
    4048
            bytes32 m2;
    4049
            bytes32 m3;
    4050
            bytes32 m4;
    4051
            bytes32 m5;
    4052
            bytes32 m6;
    4053
            /// @solidity memory-safe-assembly
    4054
            assembly {
    4055
                function writeString(pos, w) {
    4056
                    let length := 0
    4057
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4058
                    mstore(pos, length)
    4059
                    let shift := sub(256, shl(3, length))
    4060
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4061
                }
    4062
                m0 := mload(0x00)
    4063
                m1 := mload(0x20)
    4064
                m2 := mload(0x40)
    4065
                m3 := mload(0x60)
    4066
                m4 := mload(0x80)
    4067
                m5 := mload(0xa0)
    4068
                m6 := mload(0xc0)
    4069
                // Selector of `log(address,bool,string,bool)`.
    4070
                mstore(0x00, 0x50ad461d)
    4071
                mstore(0x20, p0)
    4072
                mstore(0x40, p1)
    4073
                mstore(0x60, 0x80)
    4074
                mstore(0x80, p3)
    4075
                writeString(0xa0, p2)
    4076
            }
    4077
            _sendLogPayload(0x1c, 0xc4);
    4078
            /// @solidity memory-safe-assembly
    4079
            assembly {
    4080
                mstore(0x00, m0)
    4081
                mstore(0x20, m1)
    4082
                mstore(0x40, m2)
    4083
                mstore(0x60, m3)
    4084
                mstore(0x80, m4)
    4085
                mstore(0xa0, m5)
    4086
                mstore(0xc0, m6)
    4087
            }
    4088
        }
    4089
    
                                                    
                                                
    4090
        function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    4091
            bytes32 m0;
    4092
            bytes32 m1;
    4093
            bytes32 m2;
    4094
            bytes32 m3;
    4095
            bytes32 m4;
    4096
            bytes32 m5;
    4097
            bytes32 m6;
    4098
            /// @solidity memory-safe-assembly
    4099
            assembly {
    4100
                function writeString(pos, w) {
    4101
                    let length := 0
    4102
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4103
                    mstore(pos, length)
    4104
                    let shift := sub(256, shl(3, length))
    4105
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4106
                }
    4107
                m0 := mload(0x00)
    4108
                m1 := mload(0x20)
    4109
                m2 := mload(0x40)
    4110
                m3 := mload(0x60)
    4111
                m4 := mload(0x80)
    4112
                m5 := mload(0xa0)
    4113
                m6 := mload(0xc0)
    4114
                // Selector of `log(address,bool,string,uint256)`.
    4115
                mstore(0x00, 0x80e6a20b)
    4116
                mstore(0x20, p0)
    4117
                mstore(0x40, p1)
    4118
                mstore(0x60, 0x80)
    4119
                mstore(0x80, p3)
    4120
                writeString(0xa0, p2)
    4121
            }
    4122
            _sendLogPayload(0x1c, 0xc4);
    4123
            /// @solidity memory-safe-assembly
    4124
            assembly {
    4125
                mstore(0x00, m0)
    4126
                mstore(0x20, m1)
    4127
                mstore(0x40, m2)
    4128
                mstore(0x60, m3)
    4129
                mstore(0x80, m4)
    4130
                mstore(0xa0, m5)
    4131
                mstore(0xc0, m6)
    4132
            }
    4133
        }
    4134
    
                                                    
                                                
    4135
        function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    4136
            bytes32 m0;
    4137
            bytes32 m1;
    4138
            bytes32 m2;
    4139
            bytes32 m3;
    4140
            bytes32 m4;
    4141
            bytes32 m5;
    4142
            bytes32 m6;
    4143
            bytes32 m7;
    4144
            bytes32 m8;
    4145
            /// @solidity memory-safe-assembly
    4146
            assembly {
    4147
                function writeString(pos, w) {
    4148
                    let length := 0
    4149
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4150
                    mstore(pos, length)
    4151
                    let shift := sub(256, shl(3, length))
    4152
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4153
                }
    4154
                m0 := mload(0x00)
    4155
                m1 := mload(0x20)
    4156
                m2 := mload(0x40)
    4157
                m3 := mload(0x60)
    4158
                m4 := mload(0x80)
    4159
                m5 := mload(0xa0)
    4160
                m6 := mload(0xc0)
    4161
                m7 := mload(0xe0)
    4162
                m8 := mload(0x100)
    4163
                // Selector of `log(address,bool,string,string)`.
    4164
                mstore(0x00, 0x475c5c33)
    4165
                mstore(0x20, p0)
    4166
                mstore(0x40, p1)
    4167
                mstore(0x60, 0x80)
    4168
                mstore(0x80, 0xc0)
    4169
                writeString(0xa0, p2)
    4170
                writeString(0xe0, p3)
    4171
            }
    4172
            _sendLogPayload(0x1c, 0x104);
    4173
            /// @solidity memory-safe-assembly
    4174
            assembly {
    4175
                mstore(0x00, m0)
    4176
                mstore(0x20, m1)
    4177
                mstore(0x40, m2)
    4178
                mstore(0x60, m3)
    4179
                mstore(0x80, m4)
    4180
                mstore(0xa0, m5)
    4181
                mstore(0xc0, m6)
    4182
                mstore(0xe0, m7)
    4183
                mstore(0x100, m8)
    4184
            }
    4185
        }
    4186
    
                                                    
                                                
    4187
        function log(address p0, uint256 p1, address p2, address p3) internal pure {
    4188
            bytes32 m0;
    4189
            bytes32 m1;
    4190
            bytes32 m2;
    4191
            bytes32 m3;
    4192
            bytes32 m4;
    4193
            /// @solidity memory-safe-assembly
    4194
            assembly {
    4195
                m0 := mload(0x00)
    4196
                m1 := mload(0x20)
    4197
                m2 := mload(0x40)
    4198
                m3 := mload(0x60)
    4199
                m4 := mload(0x80)
    4200
                // Selector of `log(address,uint256,address,address)`.
    4201
                mstore(0x00, 0x478d1c62)
    4202
                mstore(0x20, p0)
    4203
                mstore(0x40, p1)
    4204
                mstore(0x60, p2)
    4205
                mstore(0x80, p3)
    4206
            }
    4207
            _sendLogPayload(0x1c, 0x84);
    4208
            /// @solidity memory-safe-assembly
    4209
            assembly {
    4210
                mstore(0x00, m0)
    4211
                mstore(0x20, m1)
    4212
                mstore(0x40, m2)
    4213
                mstore(0x60, m3)
    4214
                mstore(0x80, m4)
    4215
            }
    4216
        }
    4217
    
                                                    
                                                
    4218
        function log(address p0, uint256 p1, address p2, bool p3) internal pure {
    4219
            bytes32 m0;
    4220
            bytes32 m1;
    4221
            bytes32 m2;
    4222
            bytes32 m3;
    4223
            bytes32 m4;
    4224
            /// @solidity memory-safe-assembly
    4225
            assembly {
    4226
                m0 := mload(0x00)
    4227
                m1 := mload(0x20)
    4228
                m2 := mload(0x40)
    4229
                m3 := mload(0x60)
    4230
                m4 := mload(0x80)
    4231
                // Selector of `log(address,uint256,address,bool)`.
    4232
                mstore(0x00, 0xa1bcc9b3)
    4233
                mstore(0x20, p0)
    4234
                mstore(0x40, p1)
    4235
                mstore(0x60, p2)
    4236
                mstore(0x80, p3)
    4237
            }
    4238
            _sendLogPayload(0x1c, 0x84);
    4239
            /// @solidity memory-safe-assembly
    4240
            assembly {
    4241
                mstore(0x00, m0)
    4242
                mstore(0x20, m1)
    4243
                mstore(0x40, m2)
    4244
                mstore(0x60, m3)
    4245
                mstore(0x80, m4)
    4246
            }
    4247
        }
    4248
    
                                                    
                                                
    4249
        function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
    4250
            bytes32 m0;
    4251
            bytes32 m1;
    4252
            bytes32 m2;
    4253
            bytes32 m3;
    4254
            bytes32 m4;
    4255
            /// @solidity memory-safe-assembly
    4256
            assembly {
    4257
                m0 := mload(0x00)
    4258
                m1 := mload(0x20)
    4259
                m2 := mload(0x40)
    4260
                m3 := mload(0x60)
    4261
                m4 := mload(0x80)
    4262
                // Selector of `log(address,uint256,address,uint256)`.
    4263
                mstore(0x00, 0x100f650e)
    4264
                mstore(0x20, p0)
    4265
                mstore(0x40, p1)
    4266
                mstore(0x60, p2)
    4267
                mstore(0x80, p3)
    4268
            }
    4269
            _sendLogPayload(0x1c, 0x84);
    4270
            /// @solidity memory-safe-assembly
    4271
            assembly {
    4272
                mstore(0x00, m0)
    4273
                mstore(0x20, m1)
    4274
                mstore(0x40, m2)
    4275
                mstore(0x60, m3)
    4276
                mstore(0x80, m4)
    4277
            }
    4278
        }
    4279
    
                                                    
                                                
    4280
        function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {
    4281
            bytes32 m0;
    4282
            bytes32 m1;
    4283
            bytes32 m2;
    4284
            bytes32 m3;
    4285
            bytes32 m4;
    4286
            bytes32 m5;
    4287
            bytes32 m6;
    4288
            /// @solidity memory-safe-assembly
    4289
            assembly {
    4290
                function writeString(pos, w) {
    4291
                    let length := 0
    4292
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4293
                    mstore(pos, length)
    4294
                    let shift := sub(256, shl(3, length))
    4295
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4296
                }
    4297
                m0 := mload(0x00)
    4298
                m1 := mload(0x20)
    4299
                m2 := mload(0x40)
    4300
                m3 := mload(0x60)
    4301
                m4 := mload(0x80)
    4302
                m5 := mload(0xa0)
    4303
                m6 := mload(0xc0)
    4304
                // Selector of `log(address,uint256,address,string)`.
    4305
                mstore(0x00, 0x1da986ea)
    4306
                mstore(0x20, p0)
    4307
                mstore(0x40, p1)
    4308
                mstore(0x60, p2)
    4309
                mstore(0x80, 0x80)
    4310
                writeString(0xa0, p3)
    4311
            }
    4312
            _sendLogPayload(0x1c, 0xc4);
    4313
            /// @solidity memory-safe-assembly
    4314
            assembly {
    4315
                mstore(0x00, m0)
    4316
                mstore(0x20, m1)
    4317
                mstore(0x40, m2)
    4318
                mstore(0x60, m3)
    4319
                mstore(0x80, m4)
    4320
                mstore(0xa0, m5)
    4321
                mstore(0xc0, m6)
    4322
            }
    4323
        }
    4324
    
                                                    
                                                
    4325
        function log(address p0, uint256 p1, bool p2, address p3) internal pure {
    4326
            bytes32 m0;
    4327
            bytes32 m1;
    4328
            bytes32 m2;
    4329
            bytes32 m3;
    4330
            bytes32 m4;
    4331
            /// @solidity memory-safe-assembly
    4332
            assembly {
    4333
                m0 := mload(0x00)
    4334
                m1 := mload(0x20)
    4335
                m2 := mload(0x40)
    4336
                m3 := mload(0x60)
    4337
                m4 := mload(0x80)
    4338
                // Selector of `log(address,uint256,bool,address)`.
    4339
                mstore(0x00, 0xa31bfdcc)
    4340
                mstore(0x20, p0)
    4341
                mstore(0x40, p1)
    4342
                mstore(0x60, p2)
    4343
                mstore(0x80, p3)
    4344
            }
    4345
            _sendLogPayload(0x1c, 0x84);
    4346
            /// @solidity memory-safe-assembly
    4347
            assembly {
    4348
                mstore(0x00, m0)
    4349
                mstore(0x20, m1)
    4350
                mstore(0x40, m2)
    4351
                mstore(0x60, m3)
    4352
                mstore(0x80, m4)
    4353
            }
    4354
        }
    4355
    
                                                    
                                                
    4356
        function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
    4357
            bytes32 m0;
    4358
            bytes32 m1;
    4359
            bytes32 m2;
    4360
            bytes32 m3;
    4361
            bytes32 m4;
    4362
            /// @solidity memory-safe-assembly
    4363
            assembly {
    4364
                m0 := mload(0x00)
    4365
                m1 := mload(0x20)
    4366
                m2 := mload(0x40)
    4367
                m3 := mload(0x60)
    4368
                m4 := mload(0x80)
    4369
                // Selector of `log(address,uint256,bool,bool)`.
    4370
                mstore(0x00, 0x3bf5e537)
    4371
                mstore(0x20, p0)
    4372
                mstore(0x40, p1)
    4373
                mstore(0x60, p2)
    4374
                mstore(0x80, p3)
    4375
            }
    4376
            _sendLogPayload(0x1c, 0x84);
    4377
            /// @solidity memory-safe-assembly
    4378
            assembly {
    4379
                mstore(0x00, m0)
    4380
                mstore(0x20, m1)
    4381
                mstore(0x40, m2)
    4382
                mstore(0x60, m3)
    4383
                mstore(0x80, m4)
    4384
            }
    4385
        }
    4386
    
                                                    
                                                
    4387
        function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
    4388
            bytes32 m0;
    4389
            bytes32 m1;
    4390
            bytes32 m2;
    4391
            bytes32 m3;
    4392
            bytes32 m4;
    4393
            /// @solidity memory-safe-assembly
    4394
            assembly {
    4395
                m0 := mload(0x00)
    4396
                m1 := mload(0x20)
    4397
                m2 := mload(0x40)
    4398
                m3 := mload(0x60)
    4399
                m4 := mload(0x80)
    4400
                // Selector of `log(address,uint256,bool,uint256)`.
    4401
                mstore(0x00, 0x22f6b999)
    4402
                mstore(0x20, p0)
    4403
                mstore(0x40, p1)
    4404
                mstore(0x60, p2)
    4405
                mstore(0x80, p3)
    4406
            }
    4407
            _sendLogPayload(0x1c, 0x84);
    4408
            /// @solidity memory-safe-assembly
    4409
            assembly {
    4410
                mstore(0x00, m0)
    4411
                mstore(0x20, m1)
    4412
                mstore(0x40, m2)
    4413
                mstore(0x60, m3)
    4414
                mstore(0x80, m4)
    4415
            }
    4416
        }
    4417
    
                                                    
                                                
    4418
        function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    4419
            bytes32 m0;
    4420
            bytes32 m1;
    4421
            bytes32 m2;
    4422
            bytes32 m3;
    4423
            bytes32 m4;
    4424
            bytes32 m5;
    4425
            bytes32 m6;
    4426
            /// @solidity memory-safe-assembly
    4427
            assembly {
    4428
                function writeString(pos, w) {
    4429
                    let length := 0
    4430
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4431
                    mstore(pos, length)
    4432
                    let shift := sub(256, shl(3, length))
    4433
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4434
                }
    4435
                m0 := mload(0x00)
    4436
                m1 := mload(0x20)
    4437
                m2 := mload(0x40)
    4438
                m3 := mload(0x60)
    4439
                m4 := mload(0x80)
    4440
                m5 := mload(0xa0)
    4441
                m6 := mload(0xc0)
    4442
                // Selector of `log(address,uint256,bool,string)`.
    4443
                mstore(0x00, 0xc5ad85f9)
    4444
                mstore(0x20, p0)
    4445
                mstore(0x40, p1)
    4446
                mstore(0x60, p2)
    4447
                mstore(0x80, 0x80)
    4448
                writeString(0xa0, p3)
    4449
            }
    4450
            _sendLogPayload(0x1c, 0xc4);
    4451
            /// @solidity memory-safe-assembly
    4452
            assembly {
    4453
                mstore(0x00, m0)
    4454
                mstore(0x20, m1)
    4455
                mstore(0x40, m2)
    4456
                mstore(0x60, m3)
    4457
                mstore(0x80, m4)
    4458
                mstore(0xa0, m5)
    4459
                mstore(0xc0, m6)
    4460
            }
    4461
        }
    4462
    
                                                    
                                                
    4463
        function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
    4464
            bytes32 m0;
    4465
            bytes32 m1;
    4466
            bytes32 m2;
    4467
            bytes32 m3;
    4468
            bytes32 m4;
    4469
            /// @solidity memory-safe-assembly
    4470
            assembly {
    4471
                m0 := mload(0x00)
    4472
                m1 := mload(0x20)
    4473
                m2 := mload(0x40)
    4474
                m3 := mload(0x60)
    4475
                m4 := mload(0x80)
    4476
                // Selector of `log(address,uint256,uint256,address)`.
    4477
                mstore(0x00, 0x20e3984d)
    4478
                mstore(0x20, p0)
    4479
                mstore(0x40, p1)
    4480
                mstore(0x60, p2)
    4481
                mstore(0x80, p3)
    4482
            }
    4483
            _sendLogPayload(0x1c, 0x84);
    4484
            /// @solidity memory-safe-assembly
    4485
            assembly {
    4486
                mstore(0x00, m0)
    4487
                mstore(0x20, m1)
    4488
                mstore(0x40, m2)
    4489
                mstore(0x60, m3)
    4490
                mstore(0x80, m4)
    4491
            }
    4492
        }
    4493
    
                                                    
                                                
    4494
        function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
    4495
            bytes32 m0;
    4496
            bytes32 m1;
    4497
            bytes32 m2;
    4498
            bytes32 m3;
    4499
            bytes32 m4;
    4500
            /// @solidity memory-safe-assembly
    4501
            assembly {
    4502
                m0 := mload(0x00)
    4503
                m1 := mload(0x20)
    4504
                m2 := mload(0x40)
    4505
                m3 := mload(0x60)
    4506
                m4 := mload(0x80)
    4507
                // Selector of `log(address,uint256,uint256,bool)`.
    4508
                mstore(0x00, 0x66f1bc67)
    4509
                mstore(0x20, p0)
    4510
                mstore(0x40, p1)
    4511
                mstore(0x60, p2)
    4512
                mstore(0x80, p3)
    4513
            }
    4514
            _sendLogPayload(0x1c, 0x84);
    4515
            /// @solidity memory-safe-assembly
    4516
            assembly {
    4517
                mstore(0x00, m0)
    4518
                mstore(0x20, m1)
    4519
                mstore(0x40, m2)
    4520
                mstore(0x60, m3)
    4521
                mstore(0x80, m4)
    4522
            }
    4523
        }
    4524
    
                                                    
                                                
    4525
        function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    4526
            bytes32 m0;
    4527
            bytes32 m1;
    4528
            bytes32 m2;
    4529
            bytes32 m3;
    4530
            bytes32 m4;
    4531
            /// @solidity memory-safe-assembly
    4532
            assembly {
    4533
                m0 := mload(0x00)
    4534
                m1 := mload(0x20)
    4535
                m2 := mload(0x40)
    4536
                m3 := mload(0x60)
    4537
                m4 := mload(0x80)
    4538
                // Selector of `log(address,uint256,uint256,uint256)`.
    4539
                mstore(0x00, 0x34f0e636)
    4540
                mstore(0x20, p0)
    4541
                mstore(0x40, p1)
    4542
                mstore(0x60, p2)
    4543
                mstore(0x80, p3)
    4544
            }
    4545
            _sendLogPayload(0x1c, 0x84);
    4546
            /// @solidity memory-safe-assembly
    4547
            assembly {
    4548
                mstore(0x00, m0)
    4549
                mstore(0x20, m1)
    4550
                mstore(0x40, m2)
    4551
                mstore(0x60, m3)
    4552
                mstore(0x80, m4)
    4553
            }
    4554
        }
    4555
    
                                                    
                                                
    4556
        function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    4557
            bytes32 m0;
    4558
            bytes32 m1;
    4559
            bytes32 m2;
    4560
            bytes32 m3;
    4561
            bytes32 m4;
    4562
            bytes32 m5;
    4563
            bytes32 m6;
    4564
            /// @solidity memory-safe-assembly
    4565
            assembly {
    4566
                function writeString(pos, w) {
    4567
                    let length := 0
    4568
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4569
                    mstore(pos, length)
    4570
                    let shift := sub(256, shl(3, length))
    4571
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4572
                }
    4573
                m0 := mload(0x00)
    4574
                m1 := mload(0x20)
    4575
                m2 := mload(0x40)
    4576
                m3 := mload(0x60)
    4577
                m4 := mload(0x80)
    4578
                m5 := mload(0xa0)
    4579
                m6 := mload(0xc0)
    4580
                // Selector of `log(address,uint256,uint256,string)`.
    4581
                mstore(0x00, 0x4a28c017)
    4582
                mstore(0x20, p0)
    4583
                mstore(0x40, p1)
    4584
                mstore(0x60, p2)
    4585
                mstore(0x80, 0x80)
    4586
                writeString(0xa0, p3)
    4587
            }
    4588
            _sendLogPayload(0x1c, 0xc4);
    4589
            /// @solidity memory-safe-assembly
    4590
            assembly {
    4591
                mstore(0x00, m0)
    4592
                mstore(0x20, m1)
    4593
                mstore(0x40, m2)
    4594
                mstore(0x60, m3)
    4595
                mstore(0x80, m4)
    4596
                mstore(0xa0, m5)
    4597
                mstore(0xc0, m6)
    4598
            }
    4599
        }
    4600
    
                                                    
                                                
    4601
        function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {
    4602
            bytes32 m0;
    4603
            bytes32 m1;
    4604
            bytes32 m2;
    4605
            bytes32 m3;
    4606
            bytes32 m4;
    4607
            bytes32 m5;
    4608
            bytes32 m6;
    4609
            /// @solidity memory-safe-assembly
    4610
            assembly {
    4611
                function writeString(pos, w) {
    4612
                    let length := 0
    4613
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4614
                    mstore(pos, length)
    4615
                    let shift := sub(256, shl(3, length))
    4616
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4617
                }
    4618
                m0 := mload(0x00)
    4619
                m1 := mload(0x20)
    4620
                m2 := mload(0x40)
    4621
                m3 := mload(0x60)
    4622
                m4 := mload(0x80)
    4623
                m5 := mload(0xa0)
    4624
                m6 := mload(0xc0)
    4625
                // Selector of `log(address,uint256,string,address)`.
    4626
                mstore(0x00, 0x5c430d47)
    4627
                mstore(0x20, p0)
    4628
                mstore(0x40, p1)
    4629
                mstore(0x60, 0x80)
    4630
                mstore(0x80, p3)
    4631
                writeString(0xa0, p2)
    4632
            }
    4633
            _sendLogPayload(0x1c, 0xc4);
    4634
            /// @solidity memory-safe-assembly
    4635
            assembly {
    4636
                mstore(0x00, m0)
    4637
                mstore(0x20, m1)
    4638
                mstore(0x40, m2)
    4639
                mstore(0x60, m3)
    4640
                mstore(0x80, m4)
    4641
                mstore(0xa0, m5)
    4642
                mstore(0xc0, m6)
    4643
            }
    4644
        }
    4645
    
                                                    
                                                
    4646
        function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    4647
            bytes32 m0;
    4648
            bytes32 m1;
    4649
            bytes32 m2;
    4650
            bytes32 m3;
    4651
            bytes32 m4;
    4652
            bytes32 m5;
    4653
            bytes32 m6;
    4654
            /// @solidity memory-safe-assembly
    4655
            assembly {
    4656
                function writeString(pos, w) {
    4657
                    let length := 0
    4658
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4659
                    mstore(pos, length)
    4660
                    let shift := sub(256, shl(3, length))
    4661
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4662
                }
    4663
                m0 := mload(0x00)
    4664
                m1 := mload(0x20)
    4665
                m2 := mload(0x40)
    4666
                m3 := mload(0x60)
    4667
                m4 := mload(0x80)
    4668
                m5 := mload(0xa0)
    4669
                m6 := mload(0xc0)
    4670
                // Selector of `log(address,uint256,string,bool)`.
    4671
                mstore(0x00, 0xcf18105c)
    4672
                mstore(0x20, p0)
    4673
                mstore(0x40, p1)
    4674
                mstore(0x60, 0x80)
    4675
                mstore(0x80, p3)
    4676
                writeString(0xa0, p2)
    4677
            }
    4678
            _sendLogPayload(0x1c, 0xc4);
    4679
            /// @solidity memory-safe-assembly
    4680
            assembly {
    4681
                mstore(0x00, m0)
    4682
                mstore(0x20, m1)
    4683
                mstore(0x40, m2)
    4684
                mstore(0x60, m3)
    4685
                mstore(0x80, m4)
    4686
                mstore(0xa0, m5)
    4687
                mstore(0xc0, m6)
    4688
            }
    4689
        }
    4690
    
                                                    
                                                
    4691
        function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    4692
            bytes32 m0;
    4693
            bytes32 m1;
    4694
            bytes32 m2;
    4695
            bytes32 m3;
    4696
            bytes32 m4;
    4697
            bytes32 m5;
    4698
            bytes32 m6;
    4699
            /// @solidity memory-safe-assembly
    4700
            assembly {
    4701
                function writeString(pos, w) {
    4702
                    let length := 0
    4703
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4704
                    mstore(pos, length)
    4705
                    let shift := sub(256, shl(3, length))
    4706
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4707
                }
    4708
                m0 := mload(0x00)
    4709
                m1 := mload(0x20)
    4710
                m2 := mload(0x40)
    4711
                m3 := mload(0x60)
    4712
                m4 := mload(0x80)
    4713
                m5 := mload(0xa0)
    4714
                m6 := mload(0xc0)
    4715
                // Selector of `log(address,uint256,string,uint256)`.
    4716
                mstore(0x00, 0xbf01f891)
    4717
                mstore(0x20, p0)
    4718
                mstore(0x40, p1)
    4719
                mstore(0x60, 0x80)
    4720
                mstore(0x80, p3)
    4721
                writeString(0xa0, p2)
    4722
            }
    4723
            _sendLogPayload(0x1c, 0xc4);
    4724
            /// @solidity memory-safe-assembly
    4725
            assembly {
    4726
                mstore(0x00, m0)
    4727
                mstore(0x20, m1)
    4728
                mstore(0x40, m2)
    4729
                mstore(0x60, m3)
    4730
                mstore(0x80, m4)
    4731
                mstore(0xa0, m5)
    4732
                mstore(0xc0, m6)
    4733
            }
    4734
        }
    4735
    
                                                    
                                                
    4736
        function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    4737
            bytes32 m0;
    4738
            bytes32 m1;
    4739
            bytes32 m2;
    4740
            bytes32 m3;
    4741
            bytes32 m4;
    4742
            bytes32 m5;
    4743
            bytes32 m6;
    4744
            bytes32 m7;
    4745
            bytes32 m8;
    4746
            /// @solidity memory-safe-assembly
    4747
            assembly {
    4748
                function writeString(pos, w) {
    4749
                    let length := 0
    4750
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4751
                    mstore(pos, length)
    4752
                    let shift := sub(256, shl(3, length))
    4753
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4754
                }
    4755
                m0 := mload(0x00)
    4756
                m1 := mload(0x20)
    4757
                m2 := mload(0x40)
    4758
                m3 := mload(0x60)
    4759
                m4 := mload(0x80)
    4760
                m5 := mload(0xa0)
    4761
                m6 := mload(0xc0)
    4762
                m7 := mload(0xe0)
    4763
                m8 := mload(0x100)
    4764
                // Selector of `log(address,uint256,string,string)`.
    4765
                mstore(0x00, 0x88a8c406)
    4766
                mstore(0x20, p0)
    4767
                mstore(0x40, p1)
    4768
                mstore(0x60, 0x80)
    4769
                mstore(0x80, 0xc0)
    4770
                writeString(0xa0, p2)
    4771
                writeString(0xe0, p3)
    4772
            }
    4773
            _sendLogPayload(0x1c, 0x104);
    4774
            /// @solidity memory-safe-assembly
    4775
            assembly {
    4776
                mstore(0x00, m0)
    4777
                mstore(0x20, m1)
    4778
                mstore(0x40, m2)
    4779
                mstore(0x60, m3)
    4780
                mstore(0x80, m4)
    4781
                mstore(0xa0, m5)
    4782
                mstore(0xc0, m6)
    4783
                mstore(0xe0, m7)
    4784
                mstore(0x100, m8)
    4785
            }
    4786
        }
    4787
    
                                                    
                                                
    4788
        function log(address p0, bytes32 p1, address p2, address p3) internal pure {
    4789
            bytes32 m0;
    4790
            bytes32 m1;
    4791
            bytes32 m2;
    4792
            bytes32 m3;
    4793
            bytes32 m4;
    4794
            bytes32 m5;
    4795
            bytes32 m6;
    4796
            /// @solidity memory-safe-assembly
    4797
            assembly {
    4798
                function writeString(pos, w) {
    4799
                    let length := 0
    4800
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4801
                    mstore(pos, length)
    4802
                    let shift := sub(256, shl(3, length))
    4803
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4804
                }
    4805
                m0 := mload(0x00)
    4806
                m1 := mload(0x20)
    4807
                m2 := mload(0x40)
    4808
                m3 := mload(0x60)
    4809
                m4 := mload(0x80)
    4810
                m5 := mload(0xa0)
    4811
                m6 := mload(0xc0)
    4812
                // Selector of `log(address,string,address,address)`.
    4813
                mstore(0x00, 0x0d36fa20)
    4814
                mstore(0x20, p0)
    4815
                mstore(0x40, 0x80)
    4816
                mstore(0x60, p2)
    4817
                mstore(0x80, p3)
    4818
                writeString(0xa0, p1)
    4819
            }
    4820
            _sendLogPayload(0x1c, 0xc4);
    4821
            /// @solidity memory-safe-assembly
    4822
            assembly {
    4823
                mstore(0x00, m0)
    4824
                mstore(0x20, m1)
    4825
                mstore(0x40, m2)
    4826
                mstore(0x60, m3)
    4827
                mstore(0x80, m4)
    4828
                mstore(0xa0, m5)
    4829
                mstore(0xc0, m6)
    4830
            }
    4831
        }
    4832
    
                                                    
                                                
    4833
        function log(address p0, bytes32 p1, address p2, bool p3) internal pure {
    4834
            bytes32 m0;
    4835
            bytes32 m1;
    4836
            bytes32 m2;
    4837
            bytes32 m3;
    4838
            bytes32 m4;
    4839
            bytes32 m5;
    4840
            bytes32 m6;
    4841
            /// @solidity memory-safe-assembly
    4842
            assembly {
    4843
                function writeString(pos, w) {
    4844
                    let length := 0
    4845
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4846
                    mstore(pos, length)
    4847
                    let shift := sub(256, shl(3, length))
    4848
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4849
                }
    4850
                m0 := mload(0x00)
    4851
                m1 := mload(0x20)
    4852
                m2 := mload(0x40)
    4853
                m3 := mload(0x60)
    4854
                m4 := mload(0x80)
    4855
                m5 := mload(0xa0)
    4856
                m6 := mload(0xc0)
    4857
                // Selector of `log(address,string,address,bool)`.
    4858
                mstore(0x00, 0x0df12b76)
    4859
                mstore(0x20, p0)
    4860
                mstore(0x40, 0x80)
    4861
                mstore(0x60, p2)
    4862
                mstore(0x80, p3)
    4863
                writeString(0xa0, p1)
    4864
            }
    4865
            _sendLogPayload(0x1c, 0xc4);
    4866
            /// @solidity memory-safe-assembly
    4867
            assembly {
    4868
                mstore(0x00, m0)
    4869
                mstore(0x20, m1)
    4870
                mstore(0x40, m2)
    4871
                mstore(0x60, m3)
    4872
                mstore(0x80, m4)
    4873
                mstore(0xa0, m5)
    4874
                mstore(0xc0, m6)
    4875
            }
    4876
        }
    4877
    
                                                    
                                                
    4878
        function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {
    4879
            bytes32 m0;
    4880
            bytes32 m1;
    4881
            bytes32 m2;
    4882
            bytes32 m3;
    4883
            bytes32 m4;
    4884
            bytes32 m5;
    4885
            bytes32 m6;
    4886
            /// @solidity memory-safe-assembly
    4887
            assembly {
    4888
                function writeString(pos, w) {
    4889
                    let length := 0
    4890
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4891
                    mstore(pos, length)
    4892
                    let shift := sub(256, shl(3, length))
    4893
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4894
                }
    4895
                m0 := mload(0x00)
    4896
                m1 := mload(0x20)
    4897
                m2 := mload(0x40)
    4898
                m3 := mload(0x60)
    4899
                m4 := mload(0x80)
    4900
                m5 := mload(0xa0)
    4901
                m6 := mload(0xc0)
    4902
                // Selector of `log(address,string,address,uint256)`.
    4903
                mstore(0x00, 0x457fe3cf)
    4904
                mstore(0x20, p0)
    4905
                mstore(0x40, 0x80)
    4906
                mstore(0x60, p2)
    4907
                mstore(0x80, p3)
    4908
                writeString(0xa0, p1)
    4909
            }
    4910
            _sendLogPayload(0x1c, 0xc4);
    4911
            /// @solidity memory-safe-assembly
    4912
            assembly {
    4913
                mstore(0x00, m0)
    4914
                mstore(0x20, m1)
    4915
                mstore(0x40, m2)
    4916
                mstore(0x60, m3)
    4917
                mstore(0x80, m4)
    4918
                mstore(0xa0, m5)
    4919
                mstore(0xc0, m6)
    4920
            }
    4921
        }
    4922
    
                                                    
                                                
    4923
        function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    4924
            bytes32 m0;
    4925
            bytes32 m1;
    4926
            bytes32 m2;
    4927
            bytes32 m3;
    4928
            bytes32 m4;
    4929
            bytes32 m5;
    4930
            bytes32 m6;
    4931
            bytes32 m7;
    4932
            bytes32 m8;
    4933
            /// @solidity memory-safe-assembly
    4934
            assembly {
    4935
                function writeString(pos, w) {
    4936
                    let length := 0
    4937
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4938
                    mstore(pos, length)
    4939
                    let shift := sub(256, shl(3, length))
    4940
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4941
                }
    4942
                m0 := mload(0x00)
    4943
                m1 := mload(0x20)
    4944
                m2 := mload(0x40)
    4945
                m3 := mload(0x60)
    4946
                m4 := mload(0x80)
    4947
                m5 := mload(0xa0)
    4948
                m6 := mload(0xc0)
    4949
                m7 := mload(0xe0)
    4950
                m8 := mload(0x100)
    4951
                // Selector of `log(address,string,address,string)`.
    4952
                mstore(0x00, 0xf7e36245)
    4953
                mstore(0x20, p0)
    4954
                mstore(0x40, 0x80)
    4955
                mstore(0x60, p2)
    4956
                mstore(0x80, 0xc0)
    4957
                writeString(0xa0, p1)
    4958
                writeString(0xe0, p3)
    4959
            }
    4960
            _sendLogPayload(0x1c, 0x104);
    4961
            /// @solidity memory-safe-assembly
    4962
            assembly {
    4963
                mstore(0x00, m0)
    4964
                mstore(0x20, m1)
    4965
                mstore(0x40, m2)
    4966
                mstore(0x60, m3)
    4967
                mstore(0x80, m4)
    4968
                mstore(0xa0, m5)
    4969
                mstore(0xc0, m6)
    4970
                mstore(0xe0, m7)
    4971
                mstore(0x100, m8)
    4972
            }
    4973
        }
    4974
    
                                                    
                                                
    4975
        function log(address p0, bytes32 p1, bool p2, address p3) internal pure {
    4976
            bytes32 m0;
    4977
            bytes32 m1;
    4978
            bytes32 m2;
    4979
            bytes32 m3;
    4980
            bytes32 m4;
    4981
            bytes32 m5;
    4982
            bytes32 m6;
    4983
            /// @solidity memory-safe-assembly
    4984
            assembly {
    4985
                function writeString(pos, w) {
    4986
                    let length := 0
    4987
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4988
                    mstore(pos, length)
    4989
                    let shift := sub(256, shl(3, length))
    4990
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4991
                }
    4992
                m0 := mload(0x00)
    4993
                m1 := mload(0x20)
    4994
                m2 := mload(0x40)
    4995
                m3 := mload(0x60)
    4996
                m4 := mload(0x80)
    4997
                m5 := mload(0xa0)
    4998
                m6 := mload(0xc0)
    4999
                // Selector of `log(address,string,bool,address)`.
    5000
                mstore(0x00, 0x205871c2)
    5001
                mstore(0x20, p0)
    5002
                mstore(0x40, 0x80)
    5003
                mstore(0x60, p2)
    5004
                mstore(0x80, p3)
    5005
                writeString(0xa0, p1)
    5006
            }
    5007
            _sendLogPayload(0x1c, 0xc4);
    5008
            /// @solidity memory-safe-assembly
    5009
            assembly {
    5010
                mstore(0x00, m0)
    5011
                mstore(0x20, m1)
    5012
                mstore(0x40, m2)
    5013
                mstore(0x60, m3)
    5014
                mstore(0x80, m4)
    5015
                mstore(0xa0, m5)
    5016
                mstore(0xc0, m6)
    5017
            }
    5018
        }
    5019
    
                                                    
                                                
    5020
        function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {
    5021
            bytes32 m0;
    5022
            bytes32 m1;
    5023
            bytes32 m2;
    5024
            bytes32 m3;
    5025
            bytes32 m4;
    5026
            bytes32 m5;
    5027
            bytes32 m6;
    5028
            /// @solidity memory-safe-assembly
    5029
            assembly {
    5030
                function writeString(pos, w) {
    5031
                    let length := 0
    5032
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5033
                    mstore(pos, length)
    5034
                    let shift := sub(256, shl(3, length))
    5035
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5036
                }
    5037
                m0 := mload(0x00)
    5038
                m1 := mload(0x20)
    5039
                m2 := mload(0x40)
    5040
                m3 := mload(0x60)
    5041
                m4 := mload(0x80)
    5042
                m5 := mload(0xa0)
    5043
                m6 := mload(0xc0)
    5044
                // Selector of `log(address,string,bool,bool)`.
    5045
                mstore(0x00, 0x5f1d5c9f)
    5046
                mstore(0x20, p0)
    5047
                mstore(0x40, 0x80)
    5048
                mstore(0x60, p2)
    5049
                mstore(0x80, p3)
    5050
                writeString(0xa0, p1)
    5051
            }
    5052
            _sendLogPayload(0x1c, 0xc4);
    5053
            /// @solidity memory-safe-assembly
    5054
            assembly {
    5055
                mstore(0x00, m0)
    5056
                mstore(0x20, m1)
    5057
                mstore(0x40, m2)
    5058
                mstore(0x60, m3)
    5059
                mstore(0x80, m4)
    5060
                mstore(0xa0, m5)
    5061
                mstore(0xc0, m6)
    5062
            }
    5063
        }
    5064
    
                                                    
                                                
    5065
        function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    5066
            bytes32 m0;
    5067
            bytes32 m1;
    5068
            bytes32 m2;
    5069
            bytes32 m3;
    5070
            bytes32 m4;
    5071
            bytes32 m5;
    5072
            bytes32 m6;
    5073
            /// @solidity memory-safe-assembly
    5074
            assembly {
    5075
                function writeString(pos, w) {
    5076
                    let length := 0
    5077
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5078
                    mstore(pos, length)
    5079
                    let shift := sub(256, shl(3, length))
    5080
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5081
                }
    5082
                m0 := mload(0x00)
    5083
                m1 := mload(0x20)
    5084
                m2 := mload(0x40)
    5085
                m3 := mload(0x60)
    5086
                m4 := mload(0x80)
    5087
                m5 := mload(0xa0)
    5088
                m6 := mload(0xc0)
    5089
                // Selector of `log(address,string,bool,uint256)`.
    5090
                mstore(0x00, 0x515e38b6)
    5091
                mstore(0x20, p0)
    5092
                mstore(0x40, 0x80)
    5093
                mstore(0x60, p2)
    5094
                mstore(0x80, p3)
    5095
                writeString(0xa0, p1)
    5096
            }
    5097
            _sendLogPayload(0x1c, 0xc4);
    5098
            /// @solidity memory-safe-assembly
    5099
            assembly {
    5100
                mstore(0x00, m0)
    5101
                mstore(0x20, m1)
    5102
                mstore(0x40, m2)
    5103
                mstore(0x60, m3)
    5104
                mstore(0x80, m4)
    5105
                mstore(0xa0, m5)
    5106
                mstore(0xc0, m6)
    5107
            }
    5108
        }
    5109
    
                                                    
                                                
    5110
        function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    5111
            bytes32 m0;
    5112
            bytes32 m1;
    5113
            bytes32 m2;
    5114
            bytes32 m3;
    5115
            bytes32 m4;
    5116
            bytes32 m5;
    5117
            bytes32 m6;
    5118
            bytes32 m7;
    5119
            bytes32 m8;
    5120
            /// @solidity memory-safe-assembly
    5121
            assembly {
    5122
                function writeString(pos, w) {
    5123
                    let length := 0
    5124
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5125
                    mstore(pos, length)
    5126
                    let shift := sub(256, shl(3, length))
    5127
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5128
                }
    5129
                m0 := mload(0x00)
    5130
                m1 := mload(0x20)
    5131
                m2 := mload(0x40)
    5132
                m3 := mload(0x60)
    5133
                m4 := mload(0x80)
    5134
                m5 := mload(0xa0)
    5135
                m6 := mload(0xc0)
    5136
                m7 := mload(0xe0)
    5137
                m8 := mload(0x100)
    5138
                // Selector of `log(address,string,bool,string)`.
    5139
                mstore(0x00, 0xbc0b61fe)
    5140
                mstore(0x20, p0)
    5141
                mstore(0x40, 0x80)
    5142
                mstore(0x60, p2)
    5143
                mstore(0x80, 0xc0)
    5144
                writeString(0xa0, p1)
    5145
                writeString(0xe0, p3)
    5146
            }
    5147
            _sendLogPayload(0x1c, 0x104);
    5148
            /// @solidity memory-safe-assembly
    5149
            assembly {
    5150
                mstore(0x00, m0)
    5151
                mstore(0x20, m1)
    5152
                mstore(0x40, m2)
    5153
                mstore(0x60, m3)
    5154
                mstore(0x80, m4)
    5155
                mstore(0xa0, m5)
    5156
                mstore(0xc0, m6)
    5157
                mstore(0xe0, m7)
    5158
                mstore(0x100, m8)
    5159
            }
    5160
        }
    5161
    
                                                    
                                                
    5162
        function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {
    5163
            bytes32 m0;
    5164
            bytes32 m1;
    5165
            bytes32 m2;
    5166
            bytes32 m3;
    5167
            bytes32 m4;
    5168
            bytes32 m5;
    5169
            bytes32 m6;
    5170
            /// @solidity memory-safe-assembly
    5171
            assembly {
    5172
                function writeString(pos, w) {
    5173
                    let length := 0
    5174
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5175
                    mstore(pos, length)
    5176
                    let shift := sub(256, shl(3, length))
    5177
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5178
                }
    5179
                m0 := mload(0x00)
    5180
                m1 := mload(0x20)
    5181
                m2 := mload(0x40)
    5182
                m3 := mload(0x60)
    5183
                m4 := mload(0x80)
    5184
                m5 := mload(0xa0)
    5185
                m6 := mload(0xc0)
    5186
                // Selector of `log(address,string,uint256,address)`.
    5187
                mstore(0x00, 0x63183678)
    5188
                mstore(0x20, p0)
    5189
                mstore(0x40, 0x80)
    5190
                mstore(0x60, p2)
    5191
                mstore(0x80, p3)
    5192
                writeString(0xa0, p1)
    5193
            }
    5194
            _sendLogPayload(0x1c, 0xc4);
    5195
            /// @solidity memory-safe-assembly
    5196
            assembly {
    5197
                mstore(0x00, m0)
    5198
                mstore(0x20, m1)
    5199
                mstore(0x40, m2)
    5200
                mstore(0x60, m3)
    5201
                mstore(0x80, m4)
    5202
                mstore(0xa0, m5)
    5203
                mstore(0xc0, m6)
    5204
            }
    5205
        }
    5206
    
                                                    
                                                
    5207
        function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    5208
            bytes32 m0;
    5209
            bytes32 m1;
    5210
            bytes32 m2;
    5211
            bytes32 m3;
    5212
            bytes32 m4;
    5213
            bytes32 m5;
    5214
            bytes32 m6;
    5215
            /// @solidity memory-safe-assembly
    5216
            assembly {
    5217
                function writeString(pos, w) {
    5218
                    let length := 0
    5219
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5220
                    mstore(pos, length)
    5221
                    let shift := sub(256, shl(3, length))
    5222
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5223
                }
    5224
                m0 := mload(0x00)
    5225
                m1 := mload(0x20)
    5226
                m2 := mload(0x40)
    5227
                m3 := mload(0x60)
    5228
                m4 := mload(0x80)
    5229
                m5 := mload(0xa0)
    5230
                m6 := mload(0xc0)
    5231
                // Selector of `log(address,string,uint256,bool)`.
    5232
                mstore(0x00, 0x0ef7e050)
    5233
                mstore(0x20, p0)
    5234
                mstore(0x40, 0x80)
    5235
                mstore(0x60, p2)
    5236
                mstore(0x80, p3)
    5237
                writeString(0xa0, p1)
    5238
            }
    5239
            _sendLogPayload(0x1c, 0xc4);
    5240
            /// @solidity memory-safe-assembly
    5241
            assembly {
    5242
                mstore(0x00, m0)
    5243
                mstore(0x20, m1)
    5244
                mstore(0x40, m2)
    5245
                mstore(0x60, m3)
    5246
                mstore(0x80, m4)
    5247
                mstore(0xa0, m5)
    5248
                mstore(0xc0, m6)
    5249
            }
    5250
        }
    5251
    
                                                    
                                                
    5252
        function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    5253
            bytes32 m0;
    5254
            bytes32 m1;
    5255
            bytes32 m2;
    5256
            bytes32 m3;
    5257
            bytes32 m4;
    5258
            bytes32 m5;
    5259
            bytes32 m6;
    5260
            /// @solidity memory-safe-assembly
    5261
            assembly {
    5262
                function writeString(pos, w) {
    5263
                    let length := 0
    5264
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5265
                    mstore(pos, length)
    5266
                    let shift := sub(256, shl(3, length))
    5267
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5268
                }
    5269
                m0 := mload(0x00)
    5270
                m1 := mload(0x20)
    5271
                m2 := mload(0x40)
    5272
                m3 := mload(0x60)
    5273
                m4 := mload(0x80)
    5274
                m5 := mload(0xa0)
    5275
                m6 := mload(0xc0)
    5276
                // Selector of `log(address,string,uint256,uint256)`.
    5277
                mstore(0x00, 0x1dc8e1b8)
    5278
                mstore(0x20, p0)
    5279
                mstore(0x40, 0x80)
    5280
                mstore(0x60, p2)
    5281
                mstore(0x80, p3)
    5282
                writeString(0xa0, p1)
    5283
            }
    5284
            _sendLogPayload(0x1c, 0xc4);
    5285
            /// @solidity memory-safe-assembly
    5286
            assembly {
    5287
                mstore(0x00, m0)
    5288
                mstore(0x20, m1)
    5289
                mstore(0x40, m2)
    5290
                mstore(0x60, m3)
    5291
                mstore(0x80, m4)
    5292
                mstore(0xa0, m5)
    5293
                mstore(0xc0, m6)
    5294
            }
    5295
        }
    5296
    
                                                    
                                                
    5297
        function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    5298
            bytes32 m0;
    5299
            bytes32 m1;
    5300
            bytes32 m2;
    5301
            bytes32 m3;
    5302
            bytes32 m4;
    5303
            bytes32 m5;
    5304
            bytes32 m6;
    5305
            bytes32 m7;
    5306
            bytes32 m8;
    5307
            /// @solidity memory-safe-assembly
    5308
            assembly {
    5309
                function writeString(pos, w) {
    5310
                    let length := 0
    5311
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5312
                    mstore(pos, length)
    5313
                    let shift := sub(256, shl(3, length))
    5314
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5315
                }
    5316
                m0 := mload(0x00)
    5317
                m1 := mload(0x20)
    5318
                m2 := mload(0x40)
    5319
                m3 := mload(0x60)
    5320
                m4 := mload(0x80)
    5321
                m5 := mload(0xa0)
    5322
                m6 := mload(0xc0)
    5323
                m7 := mload(0xe0)
    5324
                m8 := mload(0x100)
    5325
                // Selector of `log(address,string,uint256,string)`.
    5326
                mstore(0x00, 0x448830a8)
    5327
                mstore(0x20, p0)
    5328
                mstore(0x40, 0x80)
    5329
                mstore(0x60, p2)
    5330
                mstore(0x80, 0xc0)
    5331
                writeString(0xa0, p1)
    5332
                writeString(0xe0, p3)
    5333
            }
    5334
            _sendLogPayload(0x1c, 0x104);
    5335
            /// @solidity memory-safe-assembly
    5336
            assembly {
    5337
                mstore(0x00, m0)
    5338
                mstore(0x20, m1)
    5339
                mstore(0x40, m2)
    5340
                mstore(0x60, m3)
    5341
                mstore(0x80, m4)
    5342
                mstore(0xa0, m5)
    5343
                mstore(0xc0, m6)
    5344
                mstore(0xe0, m7)
    5345
                mstore(0x100, m8)
    5346
            }
    5347
        }
    5348
    
                                                    
                                                
    5349
        function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    5350
            bytes32 m0;
    5351
            bytes32 m1;
    5352
            bytes32 m2;
    5353
            bytes32 m3;
    5354
            bytes32 m4;
    5355
            bytes32 m5;
    5356
            bytes32 m6;
    5357
            bytes32 m7;
    5358
            bytes32 m8;
    5359
            /// @solidity memory-safe-assembly
    5360
            assembly {
    5361
                function writeString(pos, w) {
    5362
                    let length := 0
    5363
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5364
                    mstore(pos, length)
    5365
                    let shift := sub(256, shl(3, length))
    5366
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5367
                }
    5368
                m0 := mload(0x00)
    5369
                m1 := mload(0x20)
    5370
                m2 := mload(0x40)
    5371
                m3 := mload(0x60)
    5372
                m4 := mload(0x80)
    5373
                m5 := mload(0xa0)
    5374
                m6 := mload(0xc0)
    5375
                m7 := mload(0xe0)
    5376
                m8 := mload(0x100)
    5377
                // Selector of `log(address,string,string,address)`.
    5378
                mstore(0x00, 0xa04e2f87)
    5379
                mstore(0x20, p0)
    5380
                mstore(0x40, 0x80)
    5381
                mstore(0x60, 0xc0)
    5382
                mstore(0x80, p3)
    5383
                writeString(0xa0, p1)
    5384
                writeString(0xe0, p2)
    5385
            }
    5386
            _sendLogPayload(0x1c, 0x104);
    5387
            /// @solidity memory-safe-assembly
    5388
            assembly {
    5389
                mstore(0x00, m0)
    5390
                mstore(0x20, m1)
    5391
                mstore(0x40, m2)
    5392
                mstore(0x60, m3)
    5393
                mstore(0x80, m4)
    5394
                mstore(0xa0, m5)
    5395
                mstore(0xc0, m6)
    5396
                mstore(0xe0, m7)
    5397
                mstore(0x100, m8)
    5398
            }
    5399
        }
    5400
    
                                                    
                                                
    5401
        function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    5402
            bytes32 m0;
    5403
            bytes32 m1;
    5404
            bytes32 m2;
    5405
            bytes32 m3;
    5406
            bytes32 m4;
    5407
            bytes32 m5;
    5408
            bytes32 m6;
    5409
            bytes32 m7;
    5410
            bytes32 m8;
    5411
            /// @solidity memory-safe-assembly
    5412
            assembly {
    5413
                function writeString(pos, w) {
    5414
                    let length := 0
    5415
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5416
                    mstore(pos, length)
    5417
                    let shift := sub(256, shl(3, length))
    5418
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5419
                }
    5420
                m0 := mload(0x00)
    5421
                m1 := mload(0x20)
    5422
                m2 := mload(0x40)
    5423
                m3 := mload(0x60)
    5424
                m4 := mload(0x80)
    5425
                m5 := mload(0xa0)
    5426
                m6 := mload(0xc0)
    5427
                m7 := mload(0xe0)
    5428
                m8 := mload(0x100)
    5429
                // Selector of `log(address,string,string,bool)`.
    5430
                mstore(0x00, 0x35a5071f)
    5431
                mstore(0x20, p0)
    5432
                mstore(0x40, 0x80)
    5433
                mstore(0x60, 0xc0)
    5434
                mstore(0x80, p3)
    5435
                writeString(0xa0, p1)
    5436
                writeString(0xe0, p2)
    5437
            }
    5438
            _sendLogPayload(0x1c, 0x104);
    5439
            /// @solidity memory-safe-assembly
    5440
            assembly {
    5441
                mstore(0x00, m0)
    5442
                mstore(0x20, m1)
    5443
                mstore(0x40, m2)
    5444
                mstore(0x60, m3)
    5445
                mstore(0x80, m4)
    5446
                mstore(0xa0, m5)
    5447
                mstore(0xc0, m6)
    5448
                mstore(0xe0, m7)
    5449
                mstore(0x100, m8)
    5450
            }
    5451
        }
    5452
    
                                                    
                                                
    5453
        function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    5454
            bytes32 m0;
    5455
            bytes32 m1;
    5456
            bytes32 m2;
    5457
            bytes32 m3;
    5458
            bytes32 m4;
    5459
            bytes32 m5;
    5460
            bytes32 m6;
    5461
            bytes32 m7;
    5462
            bytes32 m8;
    5463
            /// @solidity memory-safe-assembly
    5464
            assembly {
    5465
                function writeString(pos, w) {
    5466
                    let length := 0
    5467
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5468
                    mstore(pos, length)
    5469
                    let shift := sub(256, shl(3, length))
    5470
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5471
                }
    5472
                m0 := mload(0x00)
    5473
                m1 := mload(0x20)
    5474
                m2 := mload(0x40)
    5475
                m3 := mload(0x60)
    5476
                m4 := mload(0x80)
    5477
                m5 := mload(0xa0)
    5478
                m6 := mload(0xc0)
    5479
                m7 := mload(0xe0)
    5480
                m8 := mload(0x100)
    5481
                // Selector of `log(address,string,string,uint256)`.
    5482
                mstore(0x00, 0x159f8927)
    5483
                mstore(0x20, p0)
    5484
                mstore(0x40, 0x80)
    5485
                mstore(0x60, 0xc0)
    5486
                mstore(0x80, p3)
    5487
                writeString(0xa0, p1)
    5488
                writeString(0xe0, p2)
    5489
            }
    5490
            _sendLogPayload(0x1c, 0x104);
    5491
            /// @solidity memory-safe-assembly
    5492
            assembly {
    5493
                mstore(0x00, m0)
    5494
                mstore(0x20, m1)
    5495
                mstore(0x40, m2)
    5496
                mstore(0x60, m3)
    5497
                mstore(0x80, m4)
    5498
                mstore(0xa0, m5)
    5499
                mstore(0xc0, m6)
    5500
                mstore(0xe0, m7)
    5501
                mstore(0x100, m8)
    5502
            }
    5503
        }
    5504
    
                                                    
                                                
    5505
        function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    5506
            bytes32 m0;
    5507
            bytes32 m1;
    5508
            bytes32 m2;
    5509
            bytes32 m3;
    5510
            bytes32 m4;
    5511
            bytes32 m5;
    5512
            bytes32 m6;
    5513
            bytes32 m7;
    5514
            bytes32 m8;
    5515
            bytes32 m9;
    5516
            bytes32 m10;
    5517
            /// @solidity memory-safe-assembly
    5518
            assembly {
    5519
                function writeString(pos, w) {
    5520
                    let length := 0
    5521
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5522
                    mstore(pos, length)
    5523
                    let shift := sub(256, shl(3, length))
    5524
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5525
                }
    5526
                m0 := mload(0x00)
    5527
                m1 := mload(0x20)
    5528
                m2 := mload(0x40)
    5529
                m3 := mload(0x60)
    5530
                m4 := mload(0x80)
    5531
                m5 := mload(0xa0)
    5532
                m6 := mload(0xc0)
    5533
                m7 := mload(0xe0)
    5534
                m8 := mload(0x100)
    5535
                m9 := mload(0x120)
    5536
                m10 := mload(0x140)
    5537
                // Selector of `log(address,string,string,string)`.
    5538
                mstore(0x00, 0x5d02c50b)
    5539
                mstore(0x20, p0)
    5540
                mstore(0x40, 0x80)
    5541
                mstore(0x60, 0xc0)
    5542
                mstore(0x80, 0x100)
    5543
                writeString(0xa0, p1)
    5544
                writeString(0xe0, p2)
    5545
                writeString(0x120, p3)
    5546
            }
    5547
            _sendLogPayload(0x1c, 0x144);
    5548
            /// @solidity memory-safe-assembly
    5549
            assembly {
    5550
                mstore(0x00, m0)
    5551
                mstore(0x20, m1)
    5552
                mstore(0x40, m2)
    5553
                mstore(0x60, m3)
    5554
                mstore(0x80, m4)
    5555
                mstore(0xa0, m5)
    5556
                mstore(0xc0, m6)
    5557
                mstore(0xe0, m7)
    5558
                mstore(0x100, m8)
    5559
                mstore(0x120, m9)
    5560
                mstore(0x140, m10)
    5561
            }
    5562
        }
    5563
    
                                                    
                                                
    5564
        function log(bool p0, address p1, address p2, address p3) internal pure {
    5565
            bytes32 m0;
    5566
            bytes32 m1;
    5567
            bytes32 m2;
    5568
            bytes32 m3;
    5569
            bytes32 m4;
    5570
            /// @solidity memory-safe-assembly
    5571
            assembly {
    5572
                m0 := mload(0x00)
    5573
                m1 := mload(0x20)
    5574
                m2 := mload(0x40)
    5575
                m3 := mload(0x60)
    5576
                m4 := mload(0x80)
    5577
                // Selector of `log(bool,address,address,address)`.
    5578
                mstore(0x00, 0x1d14d001)
    5579
                mstore(0x20, p0)
    5580
                mstore(0x40, p1)
    5581
                mstore(0x60, p2)
    5582
                mstore(0x80, p3)
    5583
            }
    5584
            _sendLogPayload(0x1c, 0x84);
    5585
            /// @solidity memory-safe-assembly
    5586
            assembly {
    5587
                mstore(0x00, m0)
    5588
                mstore(0x20, m1)
    5589
                mstore(0x40, m2)
    5590
                mstore(0x60, m3)
    5591
                mstore(0x80, m4)
    5592
            }
    5593
        }
    5594
    
                                                    
                                                
    5595
        function log(bool p0, address p1, address p2, bool p3) internal pure {
    5596
            bytes32 m0;
    5597
            bytes32 m1;
    5598
            bytes32 m2;
    5599
            bytes32 m3;
    5600
            bytes32 m4;
    5601
            /// @solidity memory-safe-assembly
    5602
            assembly {
    5603
                m0 := mload(0x00)
    5604
                m1 := mload(0x20)
    5605
                m2 := mload(0x40)
    5606
                m3 := mload(0x60)
    5607
                m4 := mload(0x80)
    5608
                // Selector of `log(bool,address,address,bool)`.
    5609
                mstore(0x00, 0x46600be0)
    5610
                mstore(0x20, p0)
    5611
                mstore(0x40, p1)
    5612
                mstore(0x60, p2)
    5613
                mstore(0x80, p3)
    5614
            }
    5615
            _sendLogPayload(0x1c, 0x84);
    5616
            /// @solidity memory-safe-assembly
    5617
            assembly {
    5618
                mstore(0x00, m0)
    5619
                mstore(0x20, m1)
    5620
                mstore(0x40, m2)
    5621
                mstore(0x60, m3)
    5622
                mstore(0x80, m4)
    5623
            }
    5624
        }
    5625
    
                                                    
                                                
    5626
        function log(bool p0, address p1, address p2, uint256 p3) internal pure {
    5627
            bytes32 m0;
    5628
            bytes32 m1;
    5629
            bytes32 m2;
    5630
            bytes32 m3;
    5631
            bytes32 m4;
    5632
            /// @solidity memory-safe-assembly
    5633
            assembly {
    5634
                m0 := mload(0x00)
    5635
                m1 := mload(0x20)
    5636
                m2 := mload(0x40)
    5637
                m3 := mload(0x60)
    5638
                m4 := mload(0x80)
    5639
                // Selector of `log(bool,address,address,uint256)`.
    5640
                mstore(0x00, 0x0c66d1be)
    5641
                mstore(0x20, p0)
    5642
                mstore(0x40, p1)
    5643
                mstore(0x60, p2)
    5644
                mstore(0x80, p3)
    5645
            }
    5646
            _sendLogPayload(0x1c, 0x84);
    5647
            /// @solidity memory-safe-assembly
    5648
            assembly {
    5649
                mstore(0x00, m0)
    5650
                mstore(0x20, m1)
    5651
                mstore(0x40, m2)
    5652
                mstore(0x60, m3)
    5653
                mstore(0x80, m4)
    5654
            }
    5655
        }
    5656
    
                                                    
                                                
    5657
        function log(bool p0, address p1, address p2, bytes32 p3) internal pure {
    5658
            bytes32 m0;
    5659
            bytes32 m1;
    5660
            bytes32 m2;
    5661
            bytes32 m3;
    5662
            bytes32 m4;
    5663
            bytes32 m5;
    5664
            bytes32 m6;
    5665
            /// @solidity memory-safe-assembly
    5666
            assembly {
    5667
                function writeString(pos, w) {
    5668
                    let length := 0
    5669
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5670
                    mstore(pos, length)
    5671
                    let shift := sub(256, shl(3, length))
    5672
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5673
                }
    5674
                m0 := mload(0x00)
    5675
                m1 := mload(0x20)
    5676
                m2 := mload(0x40)
    5677
                m3 := mload(0x60)
    5678
                m4 := mload(0x80)
    5679
                m5 := mload(0xa0)
    5680
                m6 := mload(0xc0)
    5681
                // Selector of `log(bool,address,address,string)`.
    5682
                mstore(0x00, 0xd812a167)
    5683
                mstore(0x20, p0)
    5684
                mstore(0x40, p1)
    5685
                mstore(0x60, p2)
    5686
                mstore(0x80, 0x80)
    5687
                writeString(0xa0, p3)
    5688
            }
    5689
            _sendLogPayload(0x1c, 0xc4);
    5690
            /// @solidity memory-safe-assembly
    5691
            assembly {
    5692
                mstore(0x00, m0)
    5693
                mstore(0x20, m1)
    5694
                mstore(0x40, m2)
    5695
                mstore(0x60, m3)
    5696
                mstore(0x80, m4)
    5697
                mstore(0xa0, m5)
    5698
                mstore(0xc0, m6)
    5699
            }
    5700
        }
    5701
    
                                                    
                                                
    5702
        function log(bool p0, address p1, bool p2, address p3) internal pure {
    5703
            bytes32 m0;
    5704
            bytes32 m1;
    5705
            bytes32 m2;
    5706
            bytes32 m3;
    5707
            bytes32 m4;
    5708
            /// @solidity memory-safe-assembly
    5709
            assembly {
    5710
                m0 := mload(0x00)
    5711
                m1 := mload(0x20)
    5712
                m2 := mload(0x40)
    5713
                m3 := mload(0x60)
    5714
                m4 := mload(0x80)
    5715
                // Selector of `log(bool,address,bool,address)`.
    5716
                mstore(0x00, 0x1c41a336)
    5717
                mstore(0x20, p0)
    5718
                mstore(0x40, p1)
    5719
                mstore(0x60, p2)
    5720
                mstore(0x80, p3)
    5721
            }
    5722
            _sendLogPayload(0x1c, 0x84);
    5723
            /// @solidity memory-safe-assembly
    5724
            assembly {
    5725
                mstore(0x00, m0)
    5726
                mstore(0x20, m1)
    5727
                mstore(0x40, m2)
    5728
                mstore(0x60, m3)
    5729
                mstore(0x80, m4)
    5730
            }
    5731
        }
    5732
    
                                                    
                                                
    5733
        function log(bool p0, address p1, bool p2, bool p3) internal pure {
    5734
            bytes32 m0;
    5735
            bytes32 m1;
    5736
            bytes32 m2;
    5737
            bytes32 m3;
    5738
            bytes32 m4;
    5739
            /// @solidity memory-safe-assembly
    5740
            assembly {
    5741
                m0 := mload(0x00)
    5742
                m1 := mload(0x20)
    5743
                m2 := mload(0x40)
    5744
                m3 := mload(0x60)
    5745
                m4 := mload(0x80)
    5746
                // Selector of `log(bool,address,bool,bool)`.
    5747
                mstore(0x00, 0x6a9c478b)
    5748
                mstore(0x20, p0)
    5749
                mstore(0x40, p1)
    5750
                mstore(0x60, p2)
    5751
                mstore(0x80, p3)
    5752
            }
    5753
            _sendLogPayload(0x1c, 0x84);
    5754
            /// @solidity memory-safe-assembly
    5755
            assembly {
    5756
                mstore(0x00, m0)
    5757
                mstore(0x20, m1)
    5758
                mstore(0x40, m2)
    5759
                mstore(0x60, m3)
    5760
                mstore(0x80, m4)
    5761
            }
    5762
        }
    5763
    
                                                    
                                                
    5764
        function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
    5765
            bytes32 m0;
    5766
            bytes32 m1;
    5767
            bytes32 m2;
    5768
            bytes32 m3;
    5769
            bytes32 m4;
    5770
            /// @solidity memory-safe-assembly
    5771
            assembly {
    5772
                m0 := mload(0x00)
    5773
                m1 := mload(0x20)
    5774
                m2 := mload(0x40)
    5775
                m3 := mload(0x60)
    5776
                m4 := mload(0x80)
    5777
                // Selector of `log(bool,address,bool,uint256)`.
    5778
                mstore(0x00, 0x07831502)
    5779
                mstore(0x20, p0)
    5780
                mstore(0x40, p1)
    5781
                mstore(0x60, p2)
    5782
                mstore(0x80, p3)
    5783
            }
    5784
            _sendLogPayload(0x1c, 0x84);
    5785
            /// @solidity memory-safe-assembly
    5786
            assembly {
    5787
                mstore(0x00, m0)
    5788
                mstore(0x20, m1)
    5789
                mstore(0x40, m2)
    5790
                mstore(0x60, m3)
    5791
                mstore(0x80, m4)
    5792
            }
    5793
        }
    5794
    
                                                    
                                                
    5795
        function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {
    5796
            bytes32 m0;
    5797
            bytes32 m1;
    5798
            bytes32 m2;
    5799
            bytes32 m3;
    5800
            bytes32 m4;
    5801
            bytes32 m5;
    5802
            bytes32 m6;
    5803
            /// @solidity memory-safe-assembly
    5804
            assembly {
    5805
                function writeString(pos, w) {
    5806
                    let length := 0
    5807
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5808
                    mstore(pos, length)
    5809
                    let shift := sub(256, shl(3, length))
    5810
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5811
                }
    5812
                m0 := mload(0x00)
    5813
                m1 := mload(0x20)
    5814
                m2 := mload(0x40)
    5815
                m3 := mload(0x60)
    5816
                m4 := mload(0x80)
    5817
                m5 := mload(0xa0)
    5818
                m6 := mload(0xc0)
    5819
                // Selector of `log(bool,address,bool,string)`.
    5820
                mstore(0x00, 0x4a66cb34)
    5821
                mstore(0x20, p0)
    5822
                mstore(0x40, p1)
    5823
                mstore(0x60, p2)
    5824
                mstore(0x80, 0x80)
    5825
                writeString(0xa0, p3)
    5826
            }
    5827
            _sendLogPayload(0x1c, 0xc4);
    5828
            /// @solidity memory-safe-assembly
    5829
            assembly {
    5830
                mstore(0x00, m0)
    5831
                mstore(0x20, m1)
    5832
                mstore(0x40, m2)
    5833
                mstore(0x60, m3)
    5834
                mstore(0x80, m4)
    5835
                mstore(0xa0, m5)
    5836
                mstore(0xc0, m6)
    5837
            }
    5838
        }
    5839
    
                                                    
                                                
    5840
        function log(bool p0, address p1, uint256 p2, address p3) internal pure {
    5841
            bytes32 m0;
    5842
            bytes32 m1;
    5843
            bytes32 m2;
    5844
            bytes32 m3;
    5845
            bytes32 m4;
    5846
            /// @solidity memory-safe-assembly
    5847
            assembly {
    5848
                m0 := mload(0x00)
    5849
                m1 := mload(0x20)
    5850
                m2 := mload(0x40)
    5851
                m3 := mload(0x60)
    5852
                m4 := mload(0x80)
    5853
                // Selector of `log(bool,address,uint256,address)`.
    5854
                mstore(0x00, 0x136b05dd)
    5855
                mstore(0x20, p0)
    5856
                mstore(0x40, p1)
    5857
                mstore(0x60, p2)
    5858
                mstore(0x80, p3)
    5859
            }
    5860
            _sendLogPayload(0x1c, 0x84);
    5861
            /// @solidity memory-safe-assembly
    5862
            assembly {
    5863
                mstore(0x00, m0)
    5864
                mstore(0x20, m1)
    5865
                mstore(0x40, m2)
    5866
                mstore(0x60, m3)
    5867
                mstore(0x80, m4)
    5868
            }
    5869
        }
    5870
    
                                                    
                                                
    5871
        function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
    5872
            bytes32 m0;
    5873
            bytes32 m1;
    5874
            bytes32 m2;
    5875
            bytes32 m3;
    5876
            bytes32 m4;
    5877
            /// @solidity memory-safe-assembly
    5878
            assembly {
    5879
                m0 := mload(0x00)
    5880
                m1 := mload(0x20)
    5881
                m2 := mload(0x40)
    5882
                m3 := mload(0x60)
    5883
                m4 := mload(0x80)
    5884
                // Selector of `log(bool,address,uint256,bool)`.
    5885
                mstore(0x00, 0xd6019f1c)
    5886
                mstore(0x20, p0)
    5887
                mstore(0x40, p1)
    5888
                mstore(0x60, p2)
    5889
                mstore(0x80, p3)
    5890
            }
    5891
            _sendLogPayload(0x1c, 0x84);
    5892
            /// @solidity memory-safe-assembly
    5893
            assembly {
    5894
                mstore(0x00, m0)
    5895
                mstore(0x20, m1)
    5896
                mstore(0x40, m2)
    5897
                mstore(0x60, m3)
    5898
                mstore(0x80, m4)
    5899
            }
    5900
        }
    5901
    
                                                    
                                                
    5902
        function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
    5903
            bytes32 m0;
    5904
            bytes32 m1;
    5905
            bytes32 m2;
    5906
            bytes32 m3;
    5907
            bytes32 m4;
    5908
            /// @solidity memory-safe-assembly
    5909
            assembly {
    5910
                m0 := mload(0x00)
    5911
                m1 := mload(0x20)
    5912
                m2 := mload(0x40)
    5913
                m3 := mload(0x60)
    5914
                m4 := mload(0x80)
    5915
                // Selector of `log(bool,address,uint256,uint256)`.
    5916
                mstore(0x00, 0x7bf181a1)
    5917
                mstore(0x20, p0)
    5918
                mstore(0x40, p1)
    5919
                mstore(0x60, p2)
    5920
                mstore(0x80, p3)
    5921
            }
    5922
            _sendLogPayload(0x1c, 0x84);
    5923
            /// @solidity memory-safe-assembly
    5924
            assembly {
    5925
                mstore(0x00, m0)
    5926
                mstore(0x20, m1)
    5927
                mstore(0x40, m2)
    5928
                mstore(0x60, m3)
    5929
                mstore(0x80, m4)
    5930
            }
    5931
        }
    5932
    
                                                    
                                                
    5933
        function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {
    5934
            bytes32 m0;
    5935
            bytes32 m1;
    5936
            bytes32 m2;
    5937
            bytes32 m3;
    5938
            bytes32 m4;
    5939
            bytes32 m5;
    5940
            bytes32 m6;
    5941
            /// @solidity memory-safe-assembly
    5942
            assembly {
    5943
                function writeString(pos, w) {
    5944
                    let length := 0
    5945
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5946
                    mstore(pos, length)
    5947
                    let shift := sub(256, shl(3, length))
    5948
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5949
                }
    5950
                m0 := mload(0x00)
    5951
                m1 := mload(0x20)
    5952
                m2 := mload(0x40)
    5953
                m3 := mload(0x60)
    5954
                m4 := mload(0x80)
    5955
                m5 := mload(0xa0)
    5956
                m6 := mload(0xc0)
    5957
                // Selector of `log(bool,address,uint256,string)`.
    5958
                mstore(0x00, 0x51f09ff8)
    5959
                mstore(0x20, p0)
    5960
                mstore(0x40, p1)
    5961
                mstore(0x60, p2)
    5962
                mstore(0x80, 0x80)
    5963
                writeString(0xa0, p3)
    5964
            }
    5965
            _sendLogPayload(0x1c, 0xc4);
    5966
            /// @solidity memory-safe-assembly
    5967
            assembly {
    5968
                mstore(0x00, m0)
    5969
                mstore(0x20, m1)
    5970
                mstore(0x40, m2)
    5971
                mstore(0x60, m3)
    5972
                mstore(0x80, m4)
    5973
                mstore(0xa0, m5)
    5974
                mstore(0xc0, m6)
    5975
            }
    5976
        }
    5977
    
                                                    
                                                
    5978
        function log(bool p0, address p1, bytes32 p2, address p3) internal pure {
    5979
            bytes32 m0;
    5980
            bytes32 m1;
    5981
            bytes32 m2;
    5982
            bytes32 m3;
    5983
            bytes32 m4;
    5984
            bytes32 m5;
    5985
            bytes32 m6;
    5986
            /// @solidity memory-safe-assembly
    5987
            assembly {
    5988
                function writeString(pos, w) {
    5989
                    let length := 0
    5990
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5991
                    mstore(pos, length)
    5992
                    let shift := sub(256, shl(3, length))
    5993
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5994
                }
    5995
                m0 := mload(0x00)
    5996
                m1 := mload(0x20)
    5997
                m2 := mload(0x40)
    5998
                m3 := mload(0x60)
    5999
                m4 := mload(0x80)
    6000
                m5 := mload(0xa0)
    6001
                m6 := mload(0xc0)
    6002
                // Selector of `log(bool,address,string,address)`.
    6003
                mstore(0x00, 0x6f7c603e)
    6004
                mstore(0x20, p0)
    6005
                mstore(0x40, p1)
    6006
                mstore(0x60, 0x80)
    6007
                mstore(0x80, p3)
    6008
                writeString(0xa0, p2)
    6009
            }
    6010
            _sendLogPayload(0x1c, 0xc4);
    6011
            /// @solidity memory-safe-assembly
    6012
            assembly {
    6013
                mstore(0x00, m0)
    6014
                mstore(0x20, m1)
    6015
                mstore(0x40, m2)
    6016
                mstore(0x60, m3)
    6017
                mstore(0x80, m4)
    6018
                mstore(0xa0, m5)
    6019
                mstore(0xc0, m6)
    6020
            }
    6021
        }
    6022
    
                                                    
                                                
    6023
        function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {
    6024
            bytes32 m0;
    6025
            bytes32 m1;
    6026
            bytes32 m2;
    6027
            bytes32 m3;
    6028
            bytes32 m4;
    6029
            bytes32 m5;
    6030
            bytes32 m6;
    6031
            /// @solidity memory-safe-assembly
    6032
            assembly {
    6033
                function writeString(pos, w) {
    6034
                    let length := 0
    6035
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6036
                    mstore(pos, length)
    6037
                    let shift := sub(256, shl(3, length))
    6038
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6039
                }
    6040
                m0 := mload(0x00)
    6041
                m1 := mload(0x20)
    6042
                m2 := mload(0x40)
    6043
                m3 := mload(0x60)
    6044
                m4 := mload(0x80)
    6045
                m5 := mload(0xa0)
    6046
                m6 := mload(0xc0)
    6047
                // Selector of `log(bool,address,string,bool)`.
    6048
                mstore(0x00, 0xe2bfd60b)
    6049
                mstore(0x20, p0)
    6050
                mstore(0x40, p1)
    6051
                mstore(0x60, 0x80)
    6052
                mstore(0x80, p3)
    6053
                writeString(0xa0, p2)
    6054
            }
    6055
            _sendLogPayload(0x1c, 0xc4);
    6056
            /// @solidity memory-safe-assembly
    6057
            assembly {
    6058
                mstore(0x00, m0)
    6059
                mstore(0x20, m1)
    6060
                mstore(0x40, m2)
    6061
                mstore(0x60, m3)
    6062
                mstore(0x80, m4)
    6063
                mstore(0xa0, m5)
    6064
                mstore(0xc0, m6)
    6065
            }
    6066
        }
    6067
    
                                                    
                                                
    6068
        function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {
    6069
            bytes32 m0;
    6070
            bytes32 m1;
    6071
            bytes32 m2;
    6072
            bytes32 m3;
    6073
            bytes32 m4;
    6074
            bytes32 m5;
    6075
            bytes32 m6;
    6076
            /// @solidity memory-safe-assembly
    6077
            assembly {
    6078
                function writeString(pos, w) {
    6079
                    let length := 0
    6080
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6081
                    mstore(pos, length)
    6082
                    let shift := sub(256, shl(3, length))
    6083
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6084
                }
    6085
                m0 := mload(0x00)
    6086
                m1 := mload(0x20)
    6087
                m2 := mload(0x40)
    6088
                m3 := mload(0x60)
    6089
                m4 := mload(0x80)
    6090
                m5 := mload(0xa0)
    6091
                m6 := mload(0xc0)
    6092
                // Selector of `log(bool,address,string,uint256)`.
    6093
                mstore(0x00, 0xc21f64c7)
    6094
                mstore(0x20, p0)
    6095
                mstore(0x40, p1)
    6096
                mstore(0x60, 0x80)
    6097
                mstore(0x80, p3)
    6098
                writeString(0xa0, p2)
    6099
            }
    6100
            _sendLogPayload(0x1c, 0xc4);
    6101
            /// @solidity memory-safe-assembly
    6102
            assembly {
    6103
                mstore(0x00, m0)
    6104
                mstore(0x20, m1)
    6105
                mstore(0x40, m2)
    6106
                mstore(0x60, m3)
    6107
                mstore(0x80, m4)
    6108
                mstore(0xa0, m5)
    6109
                mstore(0xc0, m6)
    6110
            }
    6111
        }
    6112
    
                                                    
                                                
    6113
        function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    6114
            bytes32 m0;
    6115
            bytes32 m1;
    6116
            bytes32 m2;
    6117
            bytes32 m3;
    6118
            bytes32 m4;
    6119
            bytes32 m5;
    6120
            bytes32 m6;
    6121
            bytes32 m7;
    6122
            bytes32 m8;
    6123
            /// @solidity memory-safe-assembly
    6124
            assembly {
    6125
                function writeString(pos, w) {
    6126
                    let length := 0
    6127
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6128
                    mstore(pos, length)
    6129
                    let shift := sub(256, shl(3, length))
    6130
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6131
                }
    6132
                m0 := mload(0x00)
    6133
                m1 := mload(0x20)
    6134
                m2 := mload(0x40)
    6135
                m3 := mload(0x60)
    6136
                m4 := mload(0x80)
    6137
                m5 := mload(0xa0)
    6138
                m6 := mload(0xc0)
    6139
                m7 := mload(0xe0)
    6140
                m8 := mload(0x100)
    6141
                // Selector of `log(bool,address,string,string)`.
    6142
                mstore(0x00, 0xa73c1db6)
    6143
                mstore(0x20, p0)
    6144
                mstore(0x40, p1)
    6145
                mstore(0x60, 0x80)
    6146
                mstore(0x80, 0xc0)
    6147
                writeString(0xa0, p2)
    6148
                writeString(0xe0, p3)
    6149
            }
    6150
            _sendLogPayload(0x1c, 0x104);
    6151
            /// @solidity memory-safe-assembly
    6152
            assembly {
    6153
                mstore(0x00, m0)
    6154
                mstore(0x20, m1)
    6155
                mstore(0x40, m2)
    6156
                mstore(0x60, m3)
    6157
                mstore(0x80, m4)
    6158
                mstore(0xa0, m5)
    6159
                mstore(0xc0, m6)
    6160
                mstore(0xe0, m7)
    6161
                mstore(0x100, m8)
    6162
            }
    6163
        }
    6164
    
                                                    
                                                
    6165
        function log(bool p0, bool p1, address p2, address p3) internal pure {
    6166
            bytes32 m0;
    6167
            bytes32 m1;
    6168
            bytes32 m2;
    6169
            bytes32 m3;
    6170
            bytes32 m4;
    6171
            /// @solidity memory-safe-assembly
    6172
            assembly {
    6173
                m0 := mload(0x00)
    6174
                m1 := mload(0x20)
    6175
                m2 := mload(0x40)
    6176
                m3 := mload(0x60)
    6177
                m4 := mload(0x80)
    6178
                // Selector of `log(bool,bool,address,address)`.
    6179
                mstore(0x00, 0xf4880ea4)
    6180
                mstore(0x20, p0)
    6181
                mstore(0x40, p1)
    6182
                mstore(0x60, p2)
    6183
                mstore(0x80, p3)
    6184
            }
    6185
            _sendLogPayload(0x1c, 0x84);
    6186
            /// @solidity memory-safe-assembly
    6187
            assembly {
    6188
                mstore(0x00, m0)
    6189
                mstore(0x20, m1)
    6190
                mstore(0x40, m2)
    6191
                mstore(0x60, m3)
    6192
                mstore(0x80, m4)
    6193
            }
    6194
        }
    6195
    
                                                    
                                                
    6196
        function log(bool p0, bool p1, address p2, bool p3) internal pure {
    6197
            bytes32 m0;
    6198
            bytes32 m1;
    6199
            bytes32 m2;
    6200
            bytes32 m3;
    6201
            bytes32 m4;
    6202
            /// @solidity memory-safe-assembly
    6203
            assembly {
    6204
                m0 := mload(0x00)
    6205
                m1 := mload(0x20)
    6206
                m2 := mload(0x40)
    6207
                m3 := mload(0x60)
    6208
                m4 := mload(0x80)
    6209
                // Selector of `log(bool,bool,address,bool)`.
    6210
                mstore(0x00, 0xc0a302d8)
    6211
                mstore(0x20, p0)
    6212
                mstore(0x40, p1)
    6213
                mstore(0x60, p2)
    6214
                mstore(0x80, p3)
    6215
            }
    6216
            _sendLogPayload(0x1c, 0x84);
    6217
            /// @solidity memory-safe-assembly
    6218
            assembly {
    6219
                mstore(0x00, m0)
    6220
                mstore(0x20, m1)
    6221
                mstore(0x40, m2)
    6222
                mstore(0x60, m3)
    6223
                mstore(0x80, m4)
    6224
            }
    6225
        }
    6226
    
                                                    
                                                
    6227
        function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
    6228
            bytes32 m0;
    6229
            bytes32 m1;
    6230
            bytes32 m2;
    6231
            bytes32 m3;
    6232
            bytes32 m4;
    6233
            /// @solidity memory-safe-assembly
    6234
            assembly {
    6235
                m0 := mload(0x00)
    6236
                m1 := mload(0x20)
    6237
                m2 := mload(0x40)
    6238
                m3 := mload(0x60)
    6239
                m4 := mload(0x80)
    6240
                // Selector of `log(bool,bool,address,uint256)`.
    6241
                mstore(0x00, 0x4c123d57)
    6242
                mstore(0x20, p0)
    6243
                mstore(0x40, p1)
    6244
                mstore(0x60, p2)
    6245
                mstore(0x80, p3)
    6246
            }
    6247
            _sendLogPayload(0x1c, 0x84);
    6248
            /// @solidity memory-safe-assembly
    6249
            assembly {
    6250
                mstore(0x00, m0)
    6251
                mstore(0x20, m1)
    6252
                mstore(0x40, m2)
    6253
                mstore(0x60, m3)
    6254
                mstore(0x80, m4)
    6255
            }
    6256
        }
    6257
    
                                                    
                                                
    6258
        function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {
    6259
            bytes32 m0;
    6260
            bytes32 m1;
    6261
            bytes32 m2;
    6262
            bytes32 m3;
    6263
            bytes32 m4;
    6264
            bytes32 m5;
    6265
            bytes32 m6;
    6266
            /// @solidity memory-safe-assembly
    6267
            assembly {
    6268
                function writeString(pos, w) {
    6269
                    let length := 0
    6270
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6271
                    mstore(pos, length)
    6272
                    let shift := sub(256, shl(3, length))
    6273
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6274
                }
    6275
                m0 := mload(0x00)
    6276
                m1 := mload(0x20)
    6277
                m2 := mload(0x40)
    6278
                m3 := mload(0x60)
    6279
                m4 := mload(0x80)
    6280
                m5 := mload(0xa0)
    6281
                m6 := mload(0xc0)
    6282
                // Selector of `log(bool,bool,address,string)`.
    6283
                mstore(0x00, 0xa0a47963)
    6284
                mstore(0x20, p0)
    6285
                mstore(0x40, p1)
    6286
                mstore(0x60, p2)
    6287
                mstore(0x80, 0x80)
    6288
                writeString(0xa0, p3)
    6289
            }
    6290
            _sendLogPayload(0x1c, 0xc4);
    6291
            /// @solidity memory-safe-assembly
    6292
            assembly {
    6293
                mstore(0x00, m0)
    6294
                mstore(0x20, m1)
    6295
                mstore(0x40, m2)
    6296
                mstore(0x60, m3)
    6297
                mstore(0x80, m4)
    6298
                mstore(0xa0, m5)
    6299
                mstore(0xc0, m6)
    6300
            }
    6301
        }
    6302
    
                                                    
                                                
    6303
        function log(bool p0, bool p1, bool p2, address p3) internal pure {
    6304
            bytes32 m0;
    6305
            bytes32 m1;
    6306
            bytes32 m2;
    6307
            bytes32 m3;
    6308
            bytes32 m4;
    6309
            /// @solidity memory-safe-assembly
    6310
            assembly {
    6311
                m0 := mload(0x00)
    6312
                m1 := mload(0x20)
    6313
                m2 := mload(0x40)
    6314
                m3 := mload(0x60)
    6315
                m4 := mload(0x80)
    6316
                // Selector of `log(bool,bool,bool,address)`.
    6317
                mstore(0x00, 0x8c329b1a)
    6318
                mstore(0x20, p0)
    6319
                mstore(0x40, p1)
    6320
                mstore(0x60, p2)
    6321
                mstore(0x80, p3)
    6322
            }
    6323
            _sendLogPayload(0x1c, 0x84);
    6324
            /// @solidity memory-safe-assembly
    6325
            assembly {
    6326
                mstore(0x00, m0)
    6327
                mstore(0x20, m1)
    6328
                mstore(0x40, m2)
    6329
                mstore(0x60, m3)
    6330
                mstore(0x80, m4)
    6331
            }
    6332
        }
    6333
    
                                                    
                                                
    6334
        function log(bool p0, bool p1, bool p2, bool p3) internal pure {
    6335
            bytes32 m0;
    6336
            bytes32 m1;
    6337
            bytes32 m2;
    6338
            bytes32 m3;
    6339
            bytes32 m4;
    6340
            /// @solidity memory-safe-assembly
    6341
            assembly {
    6342
                m0 := mload(0x00)
    6343
                m1 := mload(0x20)
    6344
                m2 := mload(0x40)
    6345
                m3 := mload(0x60)
    6346
                m4 := mload(0x80)
    6347
                // Selector of `log(bool,bool,bool,bool)`.
    6348
                mstore(0x00, 0x3b2a5ce0)
    6349
                mstore(0x20, p0)
    6350
                mstore(0x40, p1)
    6351
                mstore(0x60, p2)
    6352
                mstore(0x80, p3)
    6353
            }
    6354
            _sendLogPayload(0x1c, 0x84);
    6355
            /// @solidity memory-safe-assembly
    6356
            assembly {
    6357
                mstore(0x00, m0)
    6358
                mstore(0x20, m1)
    6359
                mstore(0x40, m2)
    6360
                mstore(0x60, m3)
    6361
                mstore(0x80, m4)
    6362
            }
    6363
        }
    6364
    
                                                    
                                                
    6365
        function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
    6366
            bytes32 m0;
    6367
            bytes32 m1;
    6368
            bytes32 m2;
    6369
            bytes32 m3;
    6370
            bytes32 m4;
    6371
            /// @solidity memory-safe-assembly
    6372
            assembly {
    6373
                m0 := mload(0x00)
    6374
                m1 := mload(0x20)
    6375
                m2 := mload(0x40)
    6376
                m3 := mload(0x60)
    6377
                m4 := mload(0x80)
    6378
                // Selector of `log(bool,bool,bool,uint256)`.
    6379
                mstore(0x00, 0x6d7045c1)
    6380
                mstore(0x20, p0)
    6381
                mstore(0x40, p1)
    6382
                mstore(0x60, p2)
    6383
                mstore(0x80, p3)
    6384
            }
    6385
            _sendLogPayload(0x1c, 0x84);
    6386
            /// @solidity memory-safe-assembly
    6387
            assembly {
    6388
                mstore(0x00, m0)
    6389
                mstore(0x20, m1)
    6390
                mstore(0x40, m2)
    6391
                mstore(0x60, m3)
    6392
                mstore(0x80, m4)
    6393
            }
    6394
        }
    6395
    
                                                    
                                                
    6396
        function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {
    6397
            bytes32 m0;
    6398
            bytes32 m1;
    6399
            bytes32 m2;
    6400
            bytes32 m3;
    6401
            bytes32 m4;
    6402
            bytes32 m5;
    6403
            bytes32 m6;
    6404
            /// @solidity memory-safe-assembly
    6405
            assembly {
    6406
                function writeString(pos, w) {
    6407
                    let length := 0
    6408
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6409
                    mstore(pos, length)
    6410
                    let shift := sub(256, shl(3, length))
    6411
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6412
                }
    6413
                m0 := mload(0x00)
    6414
                m1 := mload(0x20)
    6415
                m2 := mload(0x40)
    6416
                m3 := mload(0x60)
    6417
                m4 := mload(0x80)
    6418
                m5 := mload(0xa0)
    6419
                m6 := mload(0xc0)
    6420
                // Selector of `log(bool,bool,bool,string)`.
    6421
                mstore(0x00, 0x2ae408d4)
    6422
                mstore(0x20, p0)
    6423
                mstore(0x40, p1)
    6424
                mstore(0x60, p2)
    6425
                mstore(0x80, 0x80)
    6426
                writeString(0xa0, p3)
    6427
            }
    6428
            _sendLogPayload(0x1c, 0xc4);
    6429
            /// @solidity memory-safe-assembly
    6430
            assembly {
    6431
                mstore(0x00, m0)
    6432
                mstore(0x20, m1)
    6433
                mstore(0x40, m2)
    6434
                mstore(0x60, m3)
    6435
                mstore(0x80, m4)
    6436
                mstore(0xa0, m5)
    6437
                mstore(0xc0, m6)
    6438
            }
    6439
        }
    6440
    
                                                    
                                                
    6441
        function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
    6442
            bytes32 m0;
    6443
            bytes32 m1;
    6444
            bytes32 m2;
    6445
            bytes32 m3;
    6446
            bytes32 m4;
    6447
            /// @solidity memory-safe-assembly
    6448
            assembly {
    6449
                m0 := mload(0x00)
    6450
                m1 := mload(0x20)
    6451
                m2 := mload(0x40)
    6452
                m3 := mload(0x60)
    6453
                m4 := mload(0x80)
    6454
                // Selector of `log(bool,bool,uint256,address)`.
    6455
                mstore(0x00, 0x54a7a9a0)
    6456
                mstore(0x20, p0)
    6457
                mstore(0x40, p1)
    6458
                mstore(0x60, p2)
    6459
                mstore(0x80, p3)
    6460
            }
    6461
            _sendLogPayload(0x1c, 0x84);
    6462
            /// @solidity memory-safe-assembly
    6463
            assembly {
    6464
                mstore(0x00, m0)
    6465
                mstore(0x20, m1)
    6466
                mstore(0x40, m2)
    6467
                mstore(0x60, m3)
    6468
                mstore(0x80, m4)
    6469
            }
    6470
        }
    6471
    
                                                    
                                                
    6472
        function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
    6473
            bytes32 m0;
    6474
            bytes32 m1;
    6475
            bytes32 m2;
    6476
            bytes32 m3;
    6477
            bytes32 m4;
    6478
            /// @solidity memory-safe-assembly
    6479
            assembly {
    6480
                m0 := mload(0x00)
    6481
                m1 := mload(0x20)
    6482
                m2 := mload(0x40)
    6483
                m3 := mload(0x60)
    6484
                m4 := mload(0x80)
    6485
                // Selector of `log(bool,bool,uint256,bool)`.
    6486
                mstore(0x00, 0x619e4d0e)
    6487
                mstore(0x20, p0)
    6488
                mstore(0x40, p1)
    6489
                mstore(0x60, p2)
    6490
                mstore(0x80, p3)
    6491
            }
    6492
            _sendLogPayload(0x1c, 0x84);
    6493
            /// @solidity memory-safe-assembly
    6494
            assembly {
    6495
                mstore(0x00, m0)
    6496
                mstore(0x20, m1)
    6497
                mstore(0x40, m2)
    6498
                mstore(0x60, m3)
    6499
                mstore(0x80, m4)
    6500
            }
    6501
        }
    6502
    
                                                    
                                                
    6503
        function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
    6504
            bytes32 m0;
    6505
            bytes32 m1;
    6506
            bytes32 m2;
    6507
            bytes32 m3;
    6508
            bytes32 m4;
    6509
            /// @solidity memory-safe-assembly
    6510
            assembly {
    6511
                m0 := mload(0x00)
    6512
                m1 := mload(0x20)
    6513
                m2 := mload(0x40)
    6514
                m3 := mload(0x60)
    6515
                m4 := mload(0x80)
    6516
                // Selector of `log(bool,bool,uint256,uint256)`.
    6517
                mstore(0x00, 0x0bb00eab)
    6518
                mstore(0x20, p0)
    6519
                mstore(0x40, p1)
    6520
                mstore(0x60, p2)
    6521
                mstore(0x80, p3)
    6522
            }
    6523
            _sendLogPayload(0x1c, 0x84);
    6524
            /// @solidity memory-safe-assembly
    6525
            assembly {
    6526
                mstore(0x00, m0)
    6527
                mstore(0x20, m1)
    6528
                mstore(0x40, m2)
    6529
                mstore(0x60, m3)
    6530
                mstore(0x80, m4)
    6531
            }
    6532
        }
    6533
    
                                                    
                                                
    6534
        function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    6535
            bytes32 m0;
    6536
            bytes32 m1;
    6537
            bytes32 m2;
    6538
            bytes32 m3;
    6539
            bytes32 m4;
    6540
            bytes32 m5;
    6541
            bytes32 m6;
    6542
            /// @solidity memory-safe-assembly
    6543
            assembly {
    6544
                function writeString(pos, w) {
    6545
                    let length := 0
    6546
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6547
                    mstore(pos, length)
    6548
                    let shift := sub(256, shl(3, length))
    6549
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6550
                }
    6551
                m0 := mload(0x00)
    6552
                m1 := mload(0x20)
    6553
                m2 := mload(0x40)
    6554
                m3 := mload(0x60)
    6555
                m4 := mload(0x80)
    6556
                m5 := mload(0xa0)
    6557
                m6 := mload(0xc0)
    6558
                // Selector of `log(bool,bool,uint256,string)`.
    6559
                mstore(0x00, 0x7dd4d0e0)
    6560
                mstore(0x20, p0)
    6561
                mstore(0x40, p1)
    6562
                mstore(0x60, p2)
    6563
                mstore(0x80, 0x80)
    6564
                writeString(0xa0, p3)
    6565
            }
    6566
            _sendLogPayload(0x1c, 0xc4);
    6567
            /// @solidity memory-safe-assembly
    6568
            assembly {
    6569
                mstore(0x00, m0)
    6570
                mstore(0x20, m1)
    6571
                mstore(0x40, m2)
    6572
                mstore(0x60, m3)
    6573
                mstore(0x80, m4)
    6574
                mstore(0xa0, m5)
    6575
                mstore(0xc0, m6)
    6576
            }
    6577
        }
    6578
    
                                                    
                                                
    6579
        function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {
    6580
            bytes32 m0;
    6581
            bytes32 m1;
    6582
            bytes32 m2;
    6583
            bytes32 m3;
    6584
            bytes32 m4;
    6585
            bytes32 m5;
    6586
            bytes32 m6;
    6587
            /// @solidity memory-safe-assembly
    6588
            assembly {
    6589
                function writeString(pos, w) {
    6590
                    let length := 0
    6591
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6592
                    mstore(pos, length)
    6593
                    let shift := sub(256, shl(3, length))
    6594
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6595
                }
    6596
                m0 := mload(0x00)
    6597
                m1 := mload(0x20)
    6598
                m2 := mload(0x40)
    6599
                m3 := mload(0x60)
    6600
                m4 := mload(0x80)
    6601
                m5 := mload(0xa0)
    6602
                m6 := mload(0xc0)
    6603
                // Selector of `log(bool,bool,string,address)`.
    6604
                mstore(0x00, 0xf9ad2b89)
    6605
                mstore(0x20, p0)
    6606
                mstore(0x40, p1)
    6607
                mstore(0x60, 0x80)
    6608
                mstore(0x80, p3)
    6609
                writeString(0xa0, p2)
    6610
            }
    6611
            _sendLogPayload(0x1c, 0xc4);
    6612
            /// @solidity memory-safe-assembly
    6613
            assembly {
    6614
                mstore(0x00, m0)
    6615
                mstore(0x20, m1)
    6616
                mstore(0x40, m2)
    6617
                mstore(0x60, m3)
    6618
                mstore(0x80, m4)
    6619
                mstore(0xa0, m5)
    6620
                mstore(0xc0, m6)
    6621
            }
    6622
        }
    6623
    
                                                    
                                                
    6624
        function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {
    6625
            bytes32 m0;
    6626
            bytes32 m1;
    6627
            bytes32 m2;
    6628
            bytes32 m3;
    6629
            bytes32 m4;
    6630
            bytes32 m5;
    6631
            bytes32 m6;
    6632
            /// @solidity memory-safe-assembly
    6633
            assembly {
    6634
                function writeString(pos, w) {
    6635
                    let length := 0
    6636
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6637
                    mstore(pos, length)
    6638
                    let shift := sub(256, shl(3, length))
    6639
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6640
                }
    6641
                m0 := mload(0x00)
    6642
                m1 := mload(0x20)
    6643
                m2 := mload(0x40)
    6644
                m3 := mload(0x60)
    6645
                m4 := mload(0x80)
    6646
                m5 := mload(0xa0)
    6647
                m6 := mload(0xc0)
    6648
                // Selector of `log(bool,bool,string,bool)`.
    6649
                mstore(0x00, 0xb857163a)
    6650
                mstore(0x20, p0)
    6651
                mstore(0x40, p1)
    6652
                mstore(0x60, 0x80)
    6653
                mstore(0x80, p3)
    6654
                writeString(0xa0, p2)
    6655
            }
    6656
            _sendLogPayload(0x1c, 0xc4);
    6657
            /// @solidity memory-safe-assembly
    6658
            assembly {
    6659
                mstore(0x00, m0)
    6660
                mstore(0x20, m1)
    6661
                mstore(0x40, m2)
    6662
                mstore(0x60, m3)
    6663
                mstore(0x80, m4)
    6664
                mstore(0xa0, m5)
    6665
                mstore(0xc0, m6)
    6666
            }
    6667
        }
    6668
    
                                                    
                                                
    6669
        function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    6670
            bytes32 m0;
    6671
            bytes32 m1;
    6672
            bytes32 m2;
    6673
            bytes32 m3;
    6674
            bytes32 m4;
    6675
            bytes32 m5;
    6676
            bytes32 m6;
    6677
            /// @solidity memory-safe-assembly
    6678
            assembly {
    6679
                function writeString(pos, w) {
    6680
                    let length := 0
    6681
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6682
                    mstore(pos, length)
    6683
                    let shift := sub(256, shl(3, length))
    6684
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6685
                }
    6686
                m0 := mload(0x00)
    6687
                m1 := mload(0x20)
    6688
                m2 := mload(0x40)
    6689
                m3 := mload(0x60)
    6690
                m4 := mload(0x80)
    6691
                m5 := mload(0xa0)
    6692
                m6 := mload(0xc0)
    6693
                // Selector of `log(bool,bool,string,uint256)`.
    6694
                mstore(0x00, 0xe3a9ca2f)
    6695
                mstore(0x20, p0)
    6696
                mstore(0x40, p1)
    6697
                mstore(0x60, 0x80)
    6698
                mstore(0x80, p3)
    6699
                writeString(0xa0, p2)
    6700
            }
    6701
            _sendLogPayload(0x1c, 0xc4);
    6702
            /// @solidity memory-safe-assembly
    6703
            assembly {
    6704
                mstore(0x00, m0)
    6705
                mstore(0x20, m1)
    6706
                mstore(0x40, m2)
    6707
                mstore(0x60, m3)
    6708
                mstore(0x80, m4)
    6709
                mstore(0xa0, m5)
    6710
                mstore(0xc0, m6)
    6711
            }
    6712
        }
    6713
    
                                                    
                                                
    6714
        function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    6715
            bytes32 m0;
    6716
            bytes32 m1;
    6717
            bytes32 m2;
    6718
            bytes32 m3;
    6719
            bytes32 m4;
    6720
            bytes32 m5;
    6721
            bytes32 m6;
    6722
            bytes32 m7;
    6723
            bytes32 m8;
    6724
            /// @solidity memory-safe-assembly
    6725
            assembly {
    6726
                function writeString(pos, w) {
    6727
                    let length := 0
    6728
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6729
                    mstore(pos, length)
    6730
                    let shift := sub(256, shl(3, length))
    6731
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6732
                }
    6733
                m0 := mload(0x00)
    6734
                m1 := mload(0x20)
    6735
                m2 := mload(0x40)
    6736
                m3 := mload(0x60)
    6737
                m4 := mload(0x80)
    6738
                m5 := mload(0xa0)
    6739
                m6 := mload(0xc0)
    6740
                m7 := mload(0xe0)
    6741
                m8 := mload(0x100)
    6742
                // Selector of `log(bool,bool,string,string)`.
    6743
                mstore(0x00, 0x6d1e8751)
    6744
                mstore(0x20, p0)
    6745
                mstore(0x40, p1)
    6746
                mstore(0x60, 0x80)
    6747
                mstore(0x80, 0xc0)
    6748
                writeString(0xa0, p2)
    6749
                writeString(0xe0, p3)
    6750
            }
    6751
            _sendLogPayload(0x1c, 0x104);
    6752
            /// @solidity memory-safe-assembly
    6753
            assembly {
    6754
                mstore(0x00, m0)
    6755
                mstore(0x20, m1)
    6756
                mstore(0x40, m2)
    6757
                mstore(0x60, m3)
    6758
                mstore(0x80, m4)
    6759
                mstore(0xa0, m5)
    6760
                mstore(0xc0, m6)
    6761
                mstore(0xe0, m7)
    6762
                mstore(0x100, m8)
    6763
            }
    6764
        }
    6765
    
                                                    
                                                
    6766
        function log(bool p0, uint256 p1, address p2, address p3) internal pure {
    6767
            bytes32 m0;
    6768
            bytes32 m1;
    6769
            bytes32 m2;
    6770
            bytes32 m3;
    6771
            bytes32 m4;
    6772
            /// @solidity memory-safe-assembly
    6773
            assembly {
    6774
                m0 := mload(0x00)
    6775
                m1 := mload(0x20)
    6776
                m2 := mload(0x40)
    6777
                m3 := mload(0x60)
    6778
                m4 := mload(0x80)
    6779
                // Selector of `log(bool,uint256,address,address)`.
    6780
                mstore(0x00, 0x26f560a8)
    6781
                mstore(0x20, p0)
    6782
                mstore(0x40, p1)
    6783
                mstore(0x60, p2)
    6784
                mstore(0x80, p3)
    6785
            }
    6786
            _sendLogPayload(0x1c, 0x84);
    6787
            /// @solidity memory-safe-assembly
    6788
            assembly {
    6789
                mstore(0x00, m0)
    6790
                mstore(0x20, m1)
    6791
                mstore(0x40, m2)
    6792
                mstore(0x60, m3)
    6793
                mstore(0x80, m4)
    6794
            }
    6795
        }
    6796
    
                                                    
                                                
    6797
        function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
    6798
            bytes32 m0;
    6799
            bytes32 m1;
    6800
            bytes32 m2;
    6801
            bytes32 m3;
    6802
            bytes32 m4;
    6803
            /// @solidity memory-safe-assembly
    6804
            assembly {
    6805
                m0 := mload(0x00)
    6806
                m1 := mload(0x20)
    6807
                m2 := mload(0x40)
    6808
                m3 := mload(0x60)
    6809
                m4 := mload(0x80)
    6810
                // Selector of `log(bool,uint256,address,bool)`.
    6811
                mstore(0x00, 0xb4c314ff)
    6812
                mstore(0x20, p0)
    6813
                mstore(0x40, p1)
    6814
                mstore(0x60, p2)
    6815
                mstore(0x80, p3)
    6816
            }
    6817
            _sendLogPayload(0x1c, 0x84);
    6818
            /// @solidity memory-safe-assembly
    6819
            assembly {
    6820
                mstore(0x00, m0)
    6821
                mstore(0x20, m1)
    6822
                mstore(0x40, m2)
    6823
                mstore(0x60, m3)
    6824
                mstore(0x80, m4)
    6825
            }
    6826
        }
    6827
    
                                                    
                                                
    6828
        function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
    6829
            bytes32 m0;
    6830
            bytes32 m1;
    6831
            bytes32 m2;
    6832
            bytes32 m3;
    6833
            bytes32 m4;
    6834
            /// @solidity memory-safe-assembly
    6835
            assembly {
    6836
                m0 := mload(0x00)
    6837
                m1 := mload(0x20)
    6838
                m2 := mload(0x40)
    6839
                m3 := mload(0x60)
    6840
                m4 := mload(0x80)
    6841
                // Selector of `log(bool,uint256,address,uint256)`.
    6842
                mstore(0x00, 0x1537dc87)
    6843
                mstore(0x20, p0)
    6844
                mstore(0x40, p1)
    6845
                mstore(0x60, p2)
    6846
                mstore(0x80, p3)
    6847
            }
    6848
            _sendLogPayload(0x1c, 0x84);
    6849
            /// @solidity memory-safe-assembly
    6850
            assembly {
    6851
                mstore(0x00, m0)
    6852
                mstore(0x20, m1)
    6853
                mstore(0x40, m2)
    6854
                mstore(0x60, m3)
    6855
                mstore(0x80, m4)
    6856
            }
    6857
        }
    6858
    
                                                    
                                                
    6859
        function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {
    6860
            bytes32 m0;
    6861
            bytes32 m1;
    6862
            bytes32 m2;
    6863
            bytes32 m3;
    6864
            bytes32 m4;
    6865
            bytes32 m5;
    6866
            bytes32 m6;
    6867
            /// @solidity memory-safe-assembly
    6868
            assembly {
    6869
                function writeString(pos, w) {
    6870
                    let length := 0
    6871
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6872
                    mstore(pos, length)
    6873
                    let shift := sub(256, shl(3, length))
    6874
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6875
                }
    6876
                m0 := mload(0x00)
    6877
                m1 := mload(0x20)
    6878
                m2 := mload(0x40)
    6879
                m3 := mload(0x60)
    6880
                m4 := mload(0x80)
    6881
                m5 := mload(0xa0)
    6882
                m6 := mload(0xc0)
    6883
                // Selector of `log(bool,uint256,address,string)`.
    6884
                mstore(0x00, 0x1bb3b09a)
    6885
                mstore(0x20, p0)
    6886
                mstore(0x40, p1)
    6887
                mstore(0x60, p2)
    6888
                mstore(0x80, 0x80)
    6889
                writeString(0xa0, p3)
    6890
            }
    6891
            _sendLogPayload(0x1c, 0xc4);
    6892
            /// @solidity memory-safe-assembly
    6893
            assembly {
    6894
                mstore(0x00, m0)
    6895
                mstore(0x20, m1)
    6896
                mstore(0x40, m2)
    6897
                mstore(0x60, m3)
    6898
                mstore(0x80, m4)
    6899
                mstore(0xa0, m5)
    6900
                mstore(0xc0, m6)
    6901
            }
    6902
        }
    6903
    
                                                    
                                                
    6904
        function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
    6905
            bytes32 m0;
    6906
            bytes32 m1;
    6907
            bytes32 m2;
    6908
            bytes32 m3;
    6909
            bytes32 m4;
    6910
            /// @solidity memory-safe-assembly
    6911
            assembly {
    6912
                m0 := mload(0x00)
    6913
                m1 := mload(0x20)
    6914
                m2 := mload(0x40)
    6915
                m3 := mload(0x60)
    6916
                m4 := mload(0x80)
    6917
                // Selector of `log(bool,uint256,bool,address)`.
    6918
                mstore(0x00, 0x9acd3616)
    6919
                mstore(0x20, p0)
    6920
                mstore(0x40, p1)
    6921
                mstore(0x60, p2)
    6922
                mstore(0x80, p3)
    6923
            }
    6924
            _sendLogPayload(0x1c, 0x84);
    6925
            /// @solidity memory-safe-assembly
    6926
            assembly {
    6927
                mstore(0x00, m0)
    6928
                mstore(0x20, m1)
    6929
                mstore(0x40, m2)
    6930
                mstore(0x60, m3)
    6931
                mstore(0x80, m4)
    6932
            }
    6933
        }
    6934
    
                                                    
                                                
    6935
        function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
    6936
            bytes32 m0;
    6937
            bytes32 m1;
    6938
            bytes32 m2;
    6939
            bytes32 m3;
    6940
            bytes32 m4;
    6941
            /// @solidity memory-safe-assembly
    6942
            assembly {
    6943
                m0 := mload(0x00)
    6944
                m1 := mload(0x20)
    6945
                m2 := mload(0x40)
    6946
                m3 := mload(0x60)
    6947
                m4 := mload(0x80)
    6948
                // Selector of `log(bool,uint256,bool,bool)`.
    6949
                mstore(0x00, 0xceb5f4d7)
    6950
                mstore(0x20, p0)
    6951
                mstore(0x40, p1)
    6952
                mstore(0x60, p2)
    6953
                mstore(0x80, p3)
    6954
            }
    6955
            _sendLogPayload(0x1c, 0x84);
    6956
            /// @solidity memory-safe-assembly
    6957
            assembly {
    6958
                mstore(0x00, m0)
    6959
                mstore(0x20, m1)
    6960
                mstore(0x40, m2)
    6961
                mstore(0x60, m3)
    6962
                mstore(0x80, m4)
    6963
            }
    6964
        }
    6965
    
                                                    
                                                
    6966
        function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
    6967
            bytes32 m0;
    6968
            bytes32 m1;
    6969
            bytes32 m2;
    6970
            bytes32 m3;
    6971
            bytes32 m4;
    6972
            /// @solidity memory-safe-assembly
    6973
            assembly {
    6974
                m0 := mload(0x00)
    6975
                m1 := mload(0x20)
    6976
                m2 := mload(0x40)
    6977
                m3 := mload(0x60)
    6978
                m4 := mload(0x80)
    6979
                // Selector of `log(bool,uint256,bool,uint256)`.
    6980
                mstore(0x00, 0x7f9bbca2)
    6981
                mstore(0x20, p0)
    6982
                mstore(0x40, p1)
    6983
                mstore(0x60, p2)
    6984
                mstore(0x80, p3)
    6985
            }
    6986
            _sendLogPayload(0x1c, 0x84);
    6987
            /// @solidity memory-safe-assembly
    6988
            assembly {
    6989
                mstore(0x00, m0)
    6990
                mstore(0x20, m1)
    6991
                mstore(0x40, m2)
    6992
                mstore(0x60, m3)
    6993
                mstore(0x80, m4)
    6994
            }
    6995
        }
    6996
    
                                                    
                                                
    6997
        function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    6998
            bytes32 m0;
    6999
            bytes32 m1;
    7000
            bytes32 m2;
    7001
            bytes32 m3;
    7002
            bytes32 m4;
    7003
            bytes32 m5;
    7004
            bytes32 m6;
    7005
            /// @solidity memory-safe-assembly
    7006
            assembly {
    7007
                function writeString(pos, w) {
    7008
                    let length := 0
    7009
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7010
                    mstore(pos, length)
    7011
                    let shift := sub(256, shl(3, length))
    7012
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7013
                }
    7014
                m0 := mload(0x00)
    7015
                m1 := mload(0x20)
    7016
                m2 := mload(0x40)
    7017
                m3 := mload(0x60)
    7018
                m4 := mload(0x80)
    7019
                m5 := mload(0xa0)
    7020
                m6 := mload(0xc0)
    7021
                // Selector of `log(bool,uint256,bool,string)`.
    7022
                mstore(0x00, 0x9143dbb1)
    7023
                mstore(0x20, p0)
    7024
                mstore(0x40, p1)
    7025
                mstore(0x60, p2)
    7026
                mstore(0x80, 0x80)
    7027
                writeString(0xa0, p3)
    7028
            }
    7029
            _sendLogPayload(0x1c, 0xc4);
    7030
            /// @solidity memory-safe-assembly
    7031
            assembly {
    7032
                mstore(0x00, m0)
    7033
                mstore(0x20, m1)
    7034
                mstore(0x40, m2)
    7035
                mstore(0x60, m3)
    7036
                mstore(0x80, m4)
    7037
                mstore(0xa0, m5)
    7038
                mstore(0xc0, m6)
    7039
            }
    7040
        }
    7041
    
                                                    
                                                
    7042
        function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
    7043
            bytes32 m0;
    7044
            bytes32 m1;
    7045
            bytes32 m2;
    7046
            bytes32 m3;
    7047
            bytes32 m4;
    7048
            /// @solidity memory-safe-assembly
    7049
            assembly {
    7050
                m0 := mload(0x00)
    7051
                m1 := mload(0x20)
    7052
                m2 := mload(0x40)
    7053
                m3 := mload(0x60)
    7054
                m4 := mload(0x80)
    7055
                // Selector of `log(bool,uint256,uint256,address)`.
    7056
                mstore(0x00, 0x00dd87b9)
    7057
                mstore(0x20, p0)
    7058
                mstore(0x40, p1)
    7059
                mstore(0x60, p2)
    7060
                mstore(0x80, p3)
    7061
            }
    7062
            _sendLogPayload(0x1c, 0x84);
    7063
            /// @solidity memory-safe-assembly
    7064
            assembly {
    7065
                mstore(0x00, m0)
    7066
                mstore(0x20, m1)
    7067
                mstore(0x40, m2)
    7068
                mstore(0x60, m3)
    7069
                mstore(0x80, m4)
    7070
            }
    7071
        }
    7072
    
                                                    
                                                
    7073
        function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
    7074
            bytes32 m0;
    7075
            bytes32 m1;
    7076
            bytes32 m2;
    7077
            bytes32 m3;
    7078
            bytes32 m4;
    7079
            /// @solidity memory-safe-assembly
    7080
            assembly {
    7081
                m0 := mload(0x00)
    7082
                m1 := mload(0x20)
    7083
                m2 := mload(0x40)
    7084
                m3 := mload(0x60)
    7085
                m4 := mload(0x80)
    7086
                // Selector of `log(bool,uint256,uint256,bool)`.
    7087
                mstore(0x00, 0xbe984353)
    7088
                mstore(0x20, p0)
    7089
                mstore(0x40, p1)
    7090
                mstore(0x60, p2)
    7091
                mstore(0x80, p3)
    7092
            }
    7093
            _sendLogPayload(0x1c, 0x84);
    7094
            /// @solidity memory-safe-assembly
    7095
            assembly {
    7096
                mstore(0x00, m0)
    7097
                mstore(0x20, m1)
    7098
                mstore(0x40, m2)
    7099
                mstore(0x60, m3)
    7100
                mstore(0x80, m4)
    7101
            }
    7102
        }
    7103
    
                                                    
                                                
    7104
        function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    7105
            bytes32 m0;
    7106
            bytes32 m1;
    7107
            bytes32 m2;
    7108
            bytes32 m3;
    7109
            bytes32 m4;
    7110
            /// @solidity memory-safe-assembly
    7111
            assembly {
    7112
                m0 := mload(0x00)
    7113
                m1 := mload(0x20)
    7114
                m2 := mload(0x40)
    7115
                m3 := mload(0x60)
    7116
                m4 := mload(0x80)
    7117
                // Selector of `log(bool,uint256,uint256,uint256)`.
    7118
                mstore(0x00, 0x374bb4b2)
    7119
                mstore(0x20, p0)
    7120
                mstore(0x40, p1)
    7121
                mstore(0x60, p2)
    7122
                mstore(0x80, p3)
    7123
            }
    7124
            _sendLogPayload(0x1c, 0x84);
    7125
            /// @solidity memory-safe-assembly
    7126
            assembly {
    7127
                mstore(0x00, m0)
    7128
                mstore(0x20, m1)
    7129
                mstore(0x40, m2)
    7130
                mstore(0x60, m3)
    7131
                mstore(0x80, m4)
    7132
            }
    7133
        }
    7134
    
                                                    
                                                
    7135
        function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    7136
            bytes32 m0;
    7137
            bytes32 m1;
    7138
            bytes32 m2;
    7139
            bytes32 m3;
    7140
            bytes32 m4;
    7141
            bytes32 m5;
    7142
            bytes32 m6;
    7143
            /// @solidity memory-safe-assembly
    7144
            assembly {
    7145
                function writeString(pos, w) {
    7146
                    let length := 0
    7147
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7148
                    mstore(pos, length)
    7149
                    let shift := sub(256, shl(3, length))
    7150
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7151
                }
    7152
                m0 := mload(0x00)
    7153
                m1 := mload(0x20)
    7154
                m2 := mload(0x40)
    7155
                m3 := mload(0x60)
    7156
                m4 := mload(0x80)
    7157
                m5 := mload(0xa0)
    7158
                m6 := mload(0xc0)
    7159
                // Selector of `log(bool,uint256,uint256,string)`.
    7160
                mstore(0x00, 0x8e69fb5d)
    7161
                mstore(0x20, p0)
    7162
                mstore(0x40, p1)
    7163
                mstore(0x60, p2)
    7164
                mstore(0x80, 0x80)
    7165
                writeString(0xa0, p3)
    7166
            }
    7167
            _sendLogPayload(0x1c, 0xc4);
    7168
            /// @solidity memory-safe-assembly
    7169
            assembly {
    7170
                mstore(0x00, m0)
    7171
                mstore(0x20, m1)
    7172
                mstore(0x40, m2)
    7173
                mstore(0x60, m3)
    7174
                mstore(0x80, m4)
    7175
                mstore(0xa0, m5)
    7176
                mstore(0xc0, m6)
    7177
            }
    7178
        }
    7179
    
                                                    
                                                
    7180
        function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {
    7181
            bytes32 m0;
    7182
            bytes32 m1;
    7183
            bytes32 m2;
    7184
            bytes32 m3;
    7185
            bytes32 m4;
    7186
            bytes32 m5;
    7187
            bytes32 m6;
    7188
            /// @solidity memory-safe-assembly
    7189
            assembly {
    7190
                function writeString(pos, w) {
    7191
                    let length := 0
    7192
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7193
                    mstore(pos, length)
    7194
                    let shift := sub(256, shl(3, length))
    7195
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7196
                }
    7197
                m0 := mload(0x00)
    7198
                m1 := mload(0x20)
    7199
                m2 := mload(0x40)
    7200
                m3 := mload(0x60)
    7201
                m4 := mload(0x80)
    7202
                m5 := mload(0xa0)
    7203
                m6 := mload(0xc0)
    7204
                // Selector of `log(bool,uint256,string,address)`.
    7205
                mstore(0x00, 0xfedd1fff)
    7206
                mstore(0x20, p0)
    7207
                mstore(0x40, p1)
    7208
                mstore(0x60, 0x80)
    7209
                mstore(0x80, p3)
    7210
                writeString(0xa0, p2)
    7211
            }
    7212
            _sendLogPayload(0x1c, 0xc4);
    7213
            /// @solidity memory-safe-assembly
    7214
            assembly {
    7215
                mstore(0x00, m0)
    7216
                mstore(0x20, m1)
    7217
                mstore(0x40, m2)
    7218
                mstore(0x60, m3)
    7219
                mstore(0x80, m4)
    7220
                mstore(0xa0, m5)
    7221
                mstore(0xc0, m6)
    7222
            }
    7223
        }
    7224
    
                                                    
                                                
    7225
        function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    7226
            bytes32 m0;
    7227
            bytes32 m1;
    7228
            bytes32 m2;
    7229
            bytes32 m3;
    7230
            bytes32 m4;
    7231
            bytes32 m5;
    7232
            bytes32 m6;
    7233
            /// @solidity memory-safe-assembly
    7234
            assembly {
    7235
                function writeString(pos, w) {
    7236
                    let length := 0
    7237
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7238
                    mstore(pos, length)
    7239
                    let shift := sub(256, shl(3, length))
    7240
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7241
                }
    7242
                m0 := mload(0x00)
    7243
                m1 := mload(0x20)
    7244
                m2 := mload(0x40)
    7245
                m3 := mload(0x60)
    7246
                m4 := mload(0x80)
    7247
                m5 := mload(0xa0)
    7248
                m6 := mload(0xc0)
    7249
                // Selector of `log(bool,uint256,string,bool)`.
    7250
                mstore(0x00, 0xe5e70b2b)
    7251
                mstore(0x20, p0)
    7252
                mstore(0x40, p1)
    7253
                mstore(0x60, 0x80)
    7254
                mstore(0x80, p3)
    7255
                writeString(0xa0, p2)
    7256
            }
    7257
            _sendLogPayload(0x1c, 0xc4);
    7258
            /// @solidity memory-safe-assembly
    7259
            assembly {
    7260
                mstore(0x00, m0)
    7261
                mstore(0x20, m1)
    7262
                mstore(0x40, m2)
    7263
                mstore(0x60, m3)
    7264
                mstore(0x80, m4)
    7265
                mstore(0xa0, m5)
    7266
                mstore(0xc0, m6)
    7267
            }
    7268
        }
    7269
    
                                                    
                                                
    7270
        function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    7271
            bytes32 m0;
    7272
            bytes32 m1;
    7273
            bytes32 m2;
    7274
            bytes32 m3;
    7275
            bytes32 m4;
    7276
            bytes32 m5;
    7277
            bytes32 m6;
    7278
            /// @solidity memory-safe-assembly
    7279
            assembly {
    7280
                function writeString(pos, w) {
    7281
                    let length := 0
    7282
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7283
                    mstore(pos, length)
    7284
                    let shift := sub(256, shl(3, length))
    7285
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7286
                }
    7287
                m0 := mload(0x00)
    7288
                m1 := mload(0x20)
    7289
                m2 := mload(0x40)
    7290
                m3 := mload(0x60)
    7291
                m4 := mload(0x80)
    7292
                m5 := mload(0xa0)
    7293
                m6 := mload(0xc0)
    7294
                // Selector of `log(bool,uint256,string,uint256)`.
    7295
                mstore(0x00, 0x6a1199e2)
    7296
                mstore(0x20, p0)
    7297
                mstore(0x40, p1)
    7298
                mstore(0x60, 0x80)
    7299
                mstore(0x80, p3)
    7300
                writeString(0xa0, p2)
    7301
            }
    7302
            _sendLogPayload(0x1c, 0xc4);
    7303
            /// @solidity memory-safe-assembly
    7304
            assembly {
    7305
                mstore(0x00, m0)
    7306
                mstore(0x20, m1)
    7307
                mstore(0x40, m2)
    7308
                mstore(0x60, m3)
    7309
                mstore(0x80, m4)
    7310
                mstore(0xa0, m5)
    7311
                mstore(0xc0, m6)
    7312
            }
    7313
        }
    7314
    
                                                    
                                                
    7315
        function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    7316
            bytes32 m0;
    7317
            bytes32 m1;
    7318
            bytes32 m2;
    7319
            bytes32 m3;
    7320
            bytes32 m4;
    7321
            bytes32 m5;
    7322
            bytes32 m6;
    7323
            bytes32 m7;
    7324
            bytes32 m8;
    7325
            /// @solidity memory-safe-assembly
    7326
            assembly {
    7327
                function writeString(pos, w) {
    7328
                    let length := 0
    7329
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7330
                    mstore(pos, length)
    7331
                    let shift := sub(256, shl(3, length))
    7332
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7333
                }
    7334
                m0 := mload(0x00)
    7335
                m1 := mload(0x20)
    7336
                m2 := mload(0x40)
    7337
                m3 := mload(0x60)
    7338
                m4 := mload(0x80)
    7339
                m5 := mload(0xa0)
    7340
                m6 := mload(0xc0)
    7341
                m7 := mload(0xe0)
    7342
                m8 := mload(0x100)
    7343
                // Selector of `log(bool,uint256,string,string)`.
    7344
                mstore(0x00, 0xf5bc2249)
    7345
                mstore(0x20, p0)
    7346
                mstore(0x40, p1)
    7347
                mstore(0x60, 0x80)
    7348
                mstore(0x80, 0xc0)
    7349
                writeString(0xa0, p2)
    7350
                writeString(0xe0, p3)
    7351
            }
    7352
            _sendLogPayload(0x1c, 0x104);
    7353
            /// @solidity memory-safe-assembly
    7354
            assembly {
    7355
                mstore(0x00, m0)
    7356
                mstore(0x20, m1)
    7357
                mstore(0x40, m2)
    7358
                mstore(0x60, m3)
    7359
                mstore(0x80, m4)
    7360
                mstore(0xa0, m5)
    7361
                mstore(0xc0, m6)
    7362
                mstore(0xe0, m7)
    7363
                mstore(0x100, m8)
    7364
            }
    7365
        }
    7366
    
                                                    
                                                
    7367
        function log(bool p0, bytes32 p1, address p2, address p3) internal pure {
    7368
            bytes32 m0;
    7369
            bytes32 m1;
    7370
            bytes32 m2;
    7371
            bytes32 m3;
    7372
            bytes32 m4;
    7373
            bytes32 m5;
    7374
            bytes32 m6;
    7375
            /// @solidity memory-safe-assembly
    7376
            assembly {
    7377
                function writeString(pos, w) {
    7378
                    let length := 0
    7379
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7380
                    mstore(pos, length)
    7381
                    let shift := sub(256, shl(3, length))
    7382
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7383
                }
    7384
                m0 := mload(0x00)
    7385
                m1 := mload(0x20)
    7386
                m2 := mload(0x40)
    7387
                m3 := mload(0x60)
    7388
                m4 := mload(0x80)
    7389
                m5 := mload(0xa0)
    7390
                m6 := mload(0xc0)
    7391
                // Selector of `log(bool,string,address,address)`.
    7392
                mstore(0x00, 0x2b2b18dc)
    7393
                mstore(0x20, p0)
    7394
                mstore(0x40, 0x80)
    7395
                mstore(0x60, p2)
    7396
                mstore(0x80, p3)
    7397
                writeString(0xa0, p1)
    7398
            }
    7399
            _sendLogPayload(0x1c, 0xc4);
    7400
            /// @solidity memory-safe-assembly
    7401
            assembly {
    7402
                mstore(0x00, m0)
    7403
                mstore(0x20, m1)
    7404
                mstore(0x40, m2)
    7405
                mstore(0x60, m3)
    7406
                mstore(0x80, m4)
    7407
                mstore(0xa0, m5)
    7408
                mstore(0xc0, m6)
    7409
            }
    7410
        }
    7411
    
                                                    
                                                
    7412
        function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {
    7413
            bytes32 m0;
    7414
            bytes32 m1;
    7415
            bytes32 m2;
    7416
            bytes32 m3;
    7417
            bytes32 m4;
    7418
            bytes32 m5;
    7419
            bytes32 m6;
    7420
            /// @solidity memory-safe-assembly
    7421
            assembly {
    7422
                function writeString(pos, w) {
    7423
                    let length := 0
    7424
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7425
                    mstore(pos, length)
    7426
                    let shift := sub(256, shl(3, length))
    7427
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7428
                }
    7429
                m0 := mload(0x00)
    7430
                m1 := mload(0x20)
    7431
                m2 := mload(0x40)
    7432
                m3 := mload(0x60)
    7433
                m4 := mload(0x80)
    7434
                m5 := mload(0xa0)
    7435
                m6 := mload(0xc0)
    7436
                // Selector of `log(bool,string,address,bool)`.
    7437
                mstore(0x00, 0x6dd434ca)
    7438
                mstore(0x20, p0)
    7439
                mstore(0x40, 0x80)
    7440
                mstore(0x60, p2)
    7441
                mstore(0x80, p3)
    7442
                writeString(0xa0, p1)
    7443
            }
    7444
            _sendLogPayload(0x1c, 0xc4);
    7445
            /// @solidity memory-safe-assembly
    7446
            assembly {
    7447
                mstore(0x00, m0)
    7448
                mstore(0x20, m1)
    7449
                mstore(0x40, m2)
    7450
                mstore(0x60, m3)
    7451
                mstore(0x80, m4)
    7452
                mstore(0xa0, m5)
    7453
                mstore(0xc0, m6)
    7454
            }
    7455
        }
    7456
    
                                                    
                                                
    7457
        function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {
    7458
            bytes32 m0;
    7459
            bytes32 m1;
    7460
            bytes32 m2;
    7461
            bytes32 m3;
    7462
            bytes32 m4;
    7463
            bytes32 m5;
    7464
            bytes32 m6;
    7465
            /// @solidity memory-safe-assembly
    7466
            assembly {
    7467
                function writeString(pos, w) {
    7468
                    let length := 0
    7469
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7470
                    mstore(pos, length)
    7471
                    let shift := sub(256, shl(3, length))
    7472
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7473
                }
    7474
                m0 := mload(0x00)
    7475
                m1 := mload(0x20)
    7476
                m2 := mload(0x40)
    7477
                m3 := mload(0x60)
    7478
                m4 := mload(0x80)
    7479
                m5 := mload(0xa0)
    7480
                m6 := mload(0xc0)
    7481
                // Selector of `log(bool,string,address,uint256)`.
    7482
                mstore(0x00, 0xa5cada94)
    7483
                mstore(0x20, p0)
    7484
                mstore(0x40, 0x80)
    7485
                mstore(0x60, p2)
    7486
                mstore(0x80, p3)
    7487
                writeString(0xa0, p1)
    7488
            }
    7489
            _sendLogPayload(0x1c, 0xc4);
    7490
            /// @solidity memory-safe-assembly
    7491
            assembly {
    7492
                mstore(0x00, m0)
    7493
                mstore(0x20, m1)
    7494
                mstore(0x40, m2)
    7495
                mstore(0x60, m3)
    7496
                mstore(0x80, m4)
    7497
                mstore(0xa0, m5)
    7498
                mstore(0xc0, m6)
    7499
            }
    7500
        }
    7501
    
                                                    
                                                
    7502
        function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    7503
            bytes32 m0;
    7504
            bytes32 m1;
    7505
            bytes32 m2;
    7506
            bytes32 m3;
    7507
            bytes32 m4;
    7508
            bytes32 m5;
    7509
            bytes32 m6;
    7510
            bytes32 m7;
    7511
            bytes32 m8;
    7512
            /// @solidity memory-safe-assembly
    7513
            assembly {
    7514
                function writeString(pos, w) {
    7515
                    let length := 0
    7516
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7517
                    mstore(pos, length)
    7518
                    let shift := sub(256, shl(3, length))
    7519
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7520
                }
    7521
                m0 := mload(0x00)
    7522
                m1 := mload(0x20)
    7523
                m2 := mload(0x40)
    7524
                m3 := mload(0x60)
    7525
                m4 := mload(0x80)
    7526
                m5 := mload(0xa0)
    7527
                m6 := mload(0xc0)
    7528
                m7 := mload(0xe0)
    7529
                m8 := mload(0x100)
    7530
                // Selector of `log(bool,string,address,string)`.
    7531
                mstore(0x00, 0x12d6c788)
    7532
                mstore(0x20, p0)
    7533
                mstore(0x40, 0x80)
    7534
                mstore(0x60, p2)
    7535
                mstore(0x80, 0xc0)
    7536
                writeString(0xa0, p1)
    7537
                writeString(0xe0, p3)
    7538
            }
    7539
            _sendLogPayload(0x1c, 0x104);
    7540
            /// @solidity memory-safe-assembly
    7541
            assembly {
    7542
                mstore(0x00, m0)
    7543
                mstore(0x20, m1)
    7544
                mstore(0x40, m2)
    7545
                mstore(0x60, m3)
    7546
                mstore(0x80, m4)
    7547
                mstore(0xa0, m5)
    7548
                mstore(0xc0, m6)
    7549
                mstore(0xe0, m7)
    7550
                mstore(0x100, m8)
    7551
            }
    7552
        }
    7553
    
                                                    
                                                
    7554
        function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {
    7555
            bytes32 m0;
    7556
            bytes32 m1;
    7557
            bytes32 m2;
    7558
            bytes32 m3;
    7559
            bytes32 m4;
    7560
            bytes32 m5;
    7561
            bytes32 m6;
    7562
            /// @solidity memory-safe-assembly
    7563
            assembly {
    7564
                function writeString(pos, w) {
    7565
                    let length := 0
    7566
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7567
                    mstore(pos, length)
    7568
                    let shift := sub(256, shl(3, length))
    7569
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7570
                }
    7571
                m0 := mload(0x00)
    7572
                m1 := mload(0x20)
    7573
                m2 := mload(0x40)
    7574
                m3 := mload(0x60)
    7575
                m4 := mload(0x80)
    7576
                m5 := mload(0xa0)
    7577
                m6 := mload(0xc0)
    7578
                // Selector of `log(bool,string,bool,address)`.
    7579
                mstore(0x00, 0x538e06ab)
    7580
                mstore(0x20, p0)
    7581
                mstore(0x40, 0x80)
    7582
                mstore(0x60, p2)
    7583
                mstore(0x80, p3)
    7584
                writeString(0xa0, p1)
    7585
            }
    7586
            _sendLogPayload(0x1c, 0xc4);
    7587
            /// @solidity memory-safe-assembly
    7588
            assembly {
    7589
                mstore(0x00, m0)
    7590
                mstore(0x20, m1)
    7591
                mstore(0x40, m2)
    7592
                mstore(0x60, m3)
    7593
                mstore(0x80, m4)
    7594
                mstore(0xa0, m5)
    7595
                mstore(0xc0, m6)
    7596
            }
    7597
        }
    7598
    
                                                    
                                                
    7599
        function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {
    7600
            bytes32 m0;
    7601
            bytes32 m1;
    7602
            bytes32 m2;
    7603
            bytes32 m3;
    7604
            bytes32 m4;
    7605
            bytes32 m5;
    7606
            bytes32 m6;
    7607
            /// @solidity memory-safe-assembly
    7608
            assembly {
    7609
                function writeString(pos, w) {
    7610
                    let length := 0
    7611
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7612
                    mstore(pos, length)
    7613
                    let shift := sub(256, shl(3, length))
    7614
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7615
                }
    7616
                m0 := mload(0x00)
    7617
                m1 := mload(0x20)
    7618
                m2 := mload(0x40)
    7619
                m3 := mload(0x60)
    7620
                m4 := mload(0x80)
    7621
                m5 := mload(0xa0)
    7622
                m6 := mload(0xc0)
    7623
                // Selector of `log(bool,string,bool,bool)`.
    7624
                mstore(0x00, 0xdc5e935b)
    7625
                mstore(0x20, p0)
    7626
                mstore(0x40, 0x80)
    7627
                mstore(0x60, p2)
    7628
                mstore(0x80, p3)
    7629
                writeString(0xa0, p1)
    7630
            }
    7631
            _sendLogPayload(0x1c, 0xc4);
    7632
            /// @solidity memory-safe-assembly
    7633
            assembly {
    7634
                mstore(0x00, m0)
    7635
                mstore(0x20, m1)
    7636
                mstore(0x40, m2)
    7637
                mstore(0x60, m3)
    7638
                mstore(0x80, m4)
    7639
                mstore(0xa0, m5)
    7640
                mstore(0xc0, m6)
    7641
            }
    7642
        }
    7643
    
                                                    
                                                
    7644
        function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    7645
            bytes32 m0;
    7646
            bytes32 m1;
    7647
            bytes32 m2;
    7648
            bytes32 m3;
    7649
            bytes32 m4;
    7650
            bytes32 m5;
    7651
            bytes32 m6;
    7652
            /// @solidity memory-safe-assembly
    7653
            assembly {
    7654
                function writeString(pos, w) {
    7655
                    let length := 0
    7656
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7657
                    mstore(pos, length)
    7658
                    let shift := sub(256, shl(3, length))
    7659
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7660
                }
    7661
                m0 := mload(0x00)
    7662
                m1 := mload(0x20)
    7663
                m2 := mload(0x40)
    7664
                m3 := mload(0x60)
    7665
                m4 := mload(0x80)
    7666
                m5 := mload(0xa0)
    7667
                m6 := mload(0xc0)
    7668
                // Selector of `log(bool,string,bool,uint256)`.
    7669
                mstore(0x00, 0x1606a393)
    7670
                mstore(0x20, p0)
    7671
                mstore(0x40, 0x80)
    7672
                mstore(0x60, p2)
    7673
                mstore(0x80, p3)
    7674
                writeString(0xa0, p1)
    7675
            }
    7676
            _sendLogPayload(0x1c, 0xc4);
    7677
            /// @solidity memory-safe-assembly
    7678
            assembly {
    7679
                mstore(0x00, m0)
    7680
                mstore(0x20, m1)
    7681
                mstore(0x40, m2)
    7682
                mstore(0x60, m3)
    7683
                mstore(0x80, m4)
    7684
                mstore(0xa0, m5)
    7685
                mstore(0xc0, m6)
    7686
            }
    7687
        }
    7688
    
                                                    
                                                
    7689
        function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    7690
            bytes32 m0;
    7691
            bytes32 m1;
    7692
            bytes32 m2;
    7693
            bytes32 m3;
    7694
            bytes32 m4;
    7695
            bytes32 m5;
    7696
            bytes32 m6;
    7697
            bytes32 m7;
    7698
            bytes32 m8;
    7699
            /// @solidity memory-safe-assembly
    7700
            assembly {
    7701
                function writeString(pos, w) {
    7702
                    let length := 0
    7703
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7704
                    mstore(pos, length)
    7705
                    let shift := sub(256, shl(3, length))
    7706
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7707
                }
    7708
                m0 := mload(0x00)
    7709
                m1 := mload(0x20)
    7710
                m2 := mload(0x40)
    7711
                m3 := mload(0x60)
    7712
                m4 := mload(0x80)
    7713
                m5 := mload(0xa0)
    7714
                m6 := mload(0xc0)
    7715
                m7 := mload(0xe0)
    7716
                m8 := mload(0x100)
    7717
                // Selector of `log(bool,string,bool,string)`.
    7718
                mstore(0x00, 0x483d0416)
    7719
                mstore(0x20, p0)
    7720
                mstore(0x40, 0x80)
    7721
                mstore(0x60, p2)
    7722
                mstore(0x80, 0xc0)
    7723
                writeString(0xa0, p1)
    7724
                writeString(0xe0, p3)
    7725
            }
    7726
            _sendLogPayload(0x1c, 0x104);
    7727
            /// @solidity memory-safe-assembly
    7728
            assembly {
    7729
                mstore(0x00, m0)
    7730
                mstore(0x20, m1)
    7731
                mstore(0x40, m2)
    7732
                mstore(0x60, m3)
    7733
                mstore(0x80, m4)
    7734
                mstore(0xa0, m5)
    7735
                mstore(0xc0, m6)
    7736
                mstore(0xe0, m7)
    7737
                mstore(0x100, m8)
    7738
            }
    7739
        }
    7740
    
                                                    
                                                
    7741
        function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {
    7742
            bytes32 m0;
    7743
            bytes32 m1;
    7744
            bytes32 m2;
    7745
            bytes32 m3;
    7746
            bytes32 m4;
    7747
            bytes32 m5;
    7748
            bytes32 m6;
    7749
            /// @solidity memory-safe-assembly
    7750
            assembly {
    7751
                function writeString(pos, w) {
    7752
                    let length := 0
    7753
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7754
                    mstore(pos, length)
    7755
                    let shift := sub(256, shl(3, length))
    7756
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7757
                }
    7758
                m0 := mload(0x00)
    7759
                m1 := mload(0x20)
    7760
                m2 := mload(0x40)
    7761
                m3 := mload(0x60)
    7762
                m4 := mload(0x80)
    7763
                m5 := mload(0xa0)
    7764
                m6 := mload(0xc0)
    7765
                // Selector of `log(bool,string,uint256,address)`.
    7766
                mstore(0x00, 0x1596a1ce)
    7767
                mstore(0x20, p0)
    7768
                mstore(0x40, 0x80)
    7769
                mstore(0x60, p2)
    7770
                mstore(0x80, p3)
    7771
                writeString(0xa0, p1)
    7772
            }
    7773
            _sendLogPayload(0x1c, 0xc4);
    7774
            /// @solidity memory-safe-assembly
    7775
            assembly {
    7776
                mstore(0x00, m0)
    7777
                mstore(0x20, m1)
    7778
                mstore(0x40, m2)
    7779
                mstore(0x60, m3)
    7780
                mstore(0x80, m4)
    7781
                mstore(0xa0, m5)
    7782
                mstore(0xc0, m6)
    7783
            }
    7784
        }
    7785
    
                                                    
                                                
    7786
        function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    7787
            bytes32 m0;
    7788
            bytes32 m1;
    7789
            bytes32 m2;
    7790
            bytes32 m3;
    7791
            bytes32 m4;
    7792
            bytes32 m5;
    7793
            bytes32 m6;
    7794
            /// @solidity memory-safe-assembly
    7795
            assembly {
    7796
                function writeString(pos, w) {
    7797
                    let length := 0
    7798
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7799
                    mstore(pos, length)
    7800
                    let shift := sub(256, shl(3, length))
    7801
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7802
                }
    7803
                m0 := mload(0x00)
    7804
                m1 := mload(0x20)
    7805
                m2 := mload(0x40)
    7806
                m3 := mload(0x60)
    7807
                m4 := mload(0x80)
    7808
                m5 := mload(0xa0)
    7809
                m6 := mload(0xc0)
    7810
                // Selector of `log(bool,string,uint256,bool)`.
    7811
                mstore(0x00, 0x6b0e5d53)
    7812
                mstore(0x20, p0)
    7813
                mstore(0x40, 0x80)
    7814
                mstore(0x60, p2)
    7815
                mstore(0x80, p3)
    7816
                writeString(0xa0, p1)
    7817
            }
    7818
            _sendLogPayload(0x1c, 0xc4);
    7819
            /// @solidity memory-safe-assembly
    7820
            assembly {
    7821
                mstore(0x00, m0)
    7822
                mstore(0x20, m1)
    7823
                mstore(0x40, m2)
    7824
                mstore(0x60, m3)
    7825
                mstore(0x80, m4)
    7826
                mstore(0xa0, m5)
    7827
                mstore(0xc0, m6)
    7828
            }
    7829
        }
    7830
    
                                                    
                                                
    7831
        function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    7832
            bytes32 m0;
    7833
            bytes32 m1;
    7834
            bytes32 m2;
    7835
            bytes32 m3;
    7836
            bytes32 m4;
    7837
            bytes32 m5;
    7838
            bytes32 m6;
    7839
            /// @solidity memory-safe-assembly
    7840
            assembly {
    7841
                function writeString(pos, w) {
    7842
                    let length := 0
    7843
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7844
                    mstore(pos, length)
    7845
                    let shift := sub(256, shl(3, length))
    7846
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7847
                }
    7848
                m0 := mload(0x00)
    7849
                m1 := mload(0x20)
    7850
                m2 := mload(0x40)
    7851
                m3 := mload(0x60)
    7852
                m4 := mload(0x80)
    7853
                m5 := mload(0xa0)
    7854
                m6 := mload(0xc0)
    7855
                // Selector of `log(bool,string,uint256,uint256)`.
    7856
                mstore(0x00, 0x28863fcb)
    7857
                mstore(0x20, p0)
    7858
                mstore(0x40, 0x80)
    7859
                mstore(0x60, p2)
    7860
                mstore(0x80, p3)
    7861
                writeString(0xa0, p1)
    7862
            }
    7863
            _sendLogPayload(0x1c, 0xc4);
    7864
            /// @solidity memory-safe-assembly
    7865
            assembly {
    7866
                mstore(0x00, m0)
    7867
                mstore(0x20, m1)
    7868
                mstore(0x40, m2)
    7869
                mstore(0x60, m3)
    7870
                mstore(0x80, m4)
    7871
                mstore(0xa0, m5)
    7872
                mstore(0xc0, m6)
    7873
            }
    7874
        }
    7875
    
                                                    
                                                
    7876
        function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    7877
            bytes32 m0;
    7878
            bytes32 m1;
    7879
            bytes32 m2;
    7880
            bytes32 m3;
    7881
            bytes32 m4;
    7882
            bytes32 m5;
    7883
            bytes32 m6;
    7884
            bytes32 m7;
    7885
            bytes32 m8;
    7886
            /// @solidity memory-safe-assembly
    7887
            assembly {
    7888
                function writeString(pos, w) {
    7889
                    let length := 0
    7890
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7891
                    mstore(pos, length)
    7892
                    let shift := sub(256, shl(3, length))
    7893
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7894
                }
    7895
                m0 := mload(0x00)
    7896
                m1 := mload(0x20)
    7897
                m2 := mload(0x40)
    7898
                m3 := mload(0x60)
    7899
                m4 := mload(0x80)
    7900
                m5 := mload(0xa0)
    7901
                m6 := mload(0xc0)
    7902
                m7 := mload(0xe0)
    7903
                m8 := mload(0x100)
    7904
                // Selector of `log(bool,string,uint256,string)`.
    7905
                mstore(0x00, 0x1ad96de6)
    7906
                mstore(0x20, p0)
    7907
                mstore(0x40, 0x80)
    7908
                mstore(0x60, p2)
    7909
                mstore(0x80, 0xc0)
    7910
                writeString(0xa0, p1)
    7911
                writeString(0xe0, p3)
    7912
            }
    7913
            _sendLogPayload(0x1c, 0x104);
    7914
            /// @solidity memory-safe-assembly
    7915
            assembly {
    7916
                mstore(0x00, m0)
    7917
                mstore(0x20, m1)
    7918
                mstore(0x40, m2)
    7919
                mstore(0x60, m3)
    7920
                mstore(0x80, m4)
    7921
                mstore(0xa0, m5)
    7922
                mstore(0xc0, m6)
    7923
                mstore(0xe0, m7)
    7924
                mstore(0x100, m8)
    7925
            }
    7926
        }
    7927
    
                                                    
                                                
    7928
        function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    7929
            bytes32 m0;
    7930
            bytes32 m1;
    7931
            bytes32 m2;
    7932
            bytes32 m3;
    7933
            bytes32 m4;
    7934
            bytes32 m5;
    7935
            bytes32 m6;
    7936
            bytes32 m7;
    7937
            bytes32 m8;
    7938
            /// @solidity memory-safe-assembly
    7939
            assembly {
    7940
                function writeString(pos, w) {
    7941
                    let length := 0
    7942
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7943
                    mstore(pos, length)
    7944
                    let shift := sub(256, shl(3, length))
    7945
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7946
                }
    7947
                m0 := mload(0x00)
    7948
                m1 := mload(0x20)
    7949
                m2 := mload(0x40)
    7950
                m3 := mload(0x60)
    7951
                m4 := mload(0x80)
    7952
                m5 := mload(0xa0)
    7953
                m6 := mload(0xc0)
    7954
                m7 := mload(0xe0)
    7955
                m8 := mload(0x100)
    7956
                // Selector of `log(bool,string,string,address)`.
    7957
                mstore(0x00, 0x97d394d8)
    7958
                mstore(0x20, p0)
    7959
                mstore(0x40, 0x80)
    7960
                mstore(0x60, 0xc0)
    7961
                mstore(0x80, p3)
    7962
                writeString(0xa0, p1)
    7963
                writeString(0xe0, p2)
    7964
            }
    7965
            _sendLogPayload(0x1c, 0x104);
    7966
            /// @solidity memory-safe-assembly
    7967
            assembly {
    7968
                mstore(0x00, m0)
    7969
                mstore(0x20, m1)
    7970
                mstore(0x40, m2)
    7971
                mstore(0x60, m3)
    7972
                mstore(0x80, m4)
    7973
                mstore(0xa0, m5)
    7974
                mstore(0xc0, m6)
    7975
                mstore(0xe0, m7)
    7976
                mstore(0x100, m8)
    7977
            }
    7978
        }
    7979
    
                                                    
                                                
    7980
        function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    7981
            bytes32 m0;
    7982
            bytes32 m1;
    7983
            bytes32 m2;
    7984
            bytes32 m3;
    7985
            bytes32 m4;
    7986
            bytes32 m5;
    7987
            bytes32 m6;
    7988
            bytes32 m7;
    7989
            bytes32 m8;
    7990
            /// @solidity memory-safe-assembly
    7991
            assembly {
    7992
                function writeString(pos, w) {
    7993
                    let length := 0
    7994
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7995
                    mstore(pos, length)
    7996
                    let shift := sub(256, shl(3, length))
    7997
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7998
                }
    7999
                m0 := mload(0x00)
    8000
                m1 := mload(0x20)
    8001
                m2 := mload(0x40)
    8002
                m3 := mload(0x60)
    8003
                m4 := mload(0x80)
    8004
                m5 := mload(0xa0)
    8005
                m6 := mload(0xc0)
    8006
                m7 := mload(0xe0)
    8007
                m8 := mload(0x100)
    8008
                // Selector of `log(bool,string,string,bool)`.
    8009
                mstore(0x00, 0x1e4b87e5)
    8010
                mstore(0x20, p0)
    8011
                mstore(0x40, 0x80)
    8012
                mstore(0x60, 0xc0)
    8013
                mstore(0x80, p3)
    8014
                writeString(0xa0, p1)
    8015
                writeString(0xe0, p2)
    8016
            }
    8017
            _sendLogPayload(0x1c, 0x104);
    8018
            /// @solidity memory-safe-assembly
    8019
            assembly {
    8020
                mstore(0x00, m0)
    8021
                mstore(0x20, m1)
    8022
                mstore(0x40, m2)
    8023
                mstore(0x60, m3)
    8024
                mstore(0x80, m4)
    8025
                mstore(0xa0, m5)
    8026
                mstore(0xc0, m6)
    8027
                mstore(0xe0, m7)
    8028
                mstore(0x100, m8)
    8029
            }
    8030
        }
    8031
    
                                                    
                                                
    8032
        function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    8033
            bytes32 m0;
    8034
            bytes32 m1;
    8035
            bytes32 m2;
    8036
            bytes32 m3;
    8037
            bytes32 m4;
    8038
            bytes32 m5;
    8039
            bytes32 m6;
    8040
            bytes32 m7;
    8041
            bytes32 m8;
    8042
            /// @solidity memory-safe-assembly
    8043
            assembly {
    8044
                function writeString(pos, w) {
    8045
                    let length := 0
    8046
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8047
                    mstore(pos, length)
    8048
                    let shift := sub(256, shl(3, length))
    8049
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8050
                }
    8051
                m0 := mload(0x00)
    8052
                m1 := mload(0x20)
    8053
                m2 := mload(0x40)
    8054
                m3 := mload(0x60)
    8055
                m4 := mload(0x80)
    8056
                m5 := mload(0xa0)
    8057
                m6 := mload(0xc0)
    8058
                m7 := mload(0xe0)
    8059
                m8 := mload(0x100)
    8060
                // Selector of `log(bool,string,string,uint256)`.
    8061
                mstore(0x00, 0x7be0c3eb)
    8062
                mstore(0x20, p0)
    8063
                mstore(0x40, 0x80)
    8064
                mstore(0x60, 0xc0)
    8065
                mstore(0x80, p3)
    8066
                writeString(0xa0, p1)
    8067
                writeString(0xe0, p2)
    8068
            }
    8069
            _sendLogPayload(0x1c, 0x104);
    8070
            /// @solidity memory-safe-assembly
    8071
            assembly {
    8072
                mstore(0x00, m0)
    8073
                mstore(0x20, m1)
    8074
                mstore(0x40, m2)
    8075
                mstore(0x60, m3)
    8076
                mstore(0x80, m4)
    8077
                mstore(0xa0, m5)
    8078
                mstore(0xc0, m6)
    8079
                mstore(0xe0, m7)
    8080
                mstore(0x100, m8)
    8081
            }
    8082
        }
    8083
    
                                                    
                                                
    8084
        function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    8085
            bytes32 m0;
    8086
            bytes32 m1;
    8087
            bytes32 m2;
    8088
            bytes32 m3;
    8089
            bytes32 m4;
    8090
            bytes32 m5;
    8091
            bytes32 m6;
    8092
            bytes32 m7;
    8093
            bytes32 m8;
    8094
            bytes32 m9;
    8095
            bytes32 m10;
    8096
            /// @solidity memory-safe-assembly
    8097
            assembly {
    8098
                function writeString(pos, w) {
    8099
                    let length := 0
    8100
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8101
                    mstore(pos, length)
    8102
                    let shift := sub(256, shl(3, length))
    8103
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8104
                }
    8105
                m0 := mload(0x00)
    8106
                m1 := mload(0x20)
    8107
                m2 := mload(0x40)
    8108
                m3 := mload(0x60)
    8109
                m4 := mload(0x80)
    8110
                m5 := mload(0xa0)
    8111
                m6 := mload(0xc0)
    8112
                m7 := mload(0xe0)
    8113
                m8 := mload(0x100)
    8114
                m9 := mload(0x120)
    8115
                m10 := mload(0x140)
    8116
                // Selector of `log(bool,string,string,string)`.
    8117
                mstore(0x00, 0x1762e32a)
    8118
                mstore(0x20, p0)
    8119
                mstore(0x40, 0x80)
    8120
                mstore(0x60, 0xc0)
    8121
                mstore(0x80, 0x100)
    8122
                writeString(0xa0, p1)
    8123
                writeString(0xe0, p2)
    8124
                writeString(0x120, p3)
    8125
            }
    8126
            _sendLogPayload(0x1c, 0x144);
    8127
            /// @solidity memory-safe-assembly
    8128
            assembly {
    8129
                mstore(0x00, m0)
    8130
                mstore(0x20, m1)
    8131
                mstore(0x40, m2)
    8132
                mstore(0x60, m3)
    8133
                mstore(0x80, m4)
    8134
                mstore(0xa0, m5)
    8135
                mstore(0xc0, m6)
    8136
                mstore(0xe0, m7)
    8137
                mstore(0x100, m8)
    8138
                mstore(0x120, m9)
    8139
                mstore(0x140, m10)
    8140
            }
    8141
        }
    8142
    
                                                    
                                                
    8143
        function log(uint256 p0, address p1, address p2, address p3) internal pure {
    8144
            bytes32 m0;
    8145
            bytes32 m1;
    8146
            bytes32 m2;
    8147
            bytes32 m3;
    8148
            bytes32 m4;
    8149
            /// @solidity memory-safe-assembly
    8150
            assembly {
    8151
                m0 := mload(0x00)
    8152
                m1 := mload(0x20)
    8153
                m2 := mload(0x40)
    8154
                m3 := mload(0x60)
    8155
                m4 := mload(0x80)
    8156
                // Selector of `log(uint256,address,address,address)`.
    8157
                mstore(0x00, 0x2488b414)
    8158
                mstore(0x20, p0)
    8159
                mstore(0x40, p1)
    8160
                mstore(0x60, p2)
    8161
                mstore(0x80, p3)
    8162
            }
    8163
            _sendLogPayload(0x1c, 0x84);
    8164
            /// @solidity memory-safe-assembly
    8165
            assembly {
    8166
                mstore(0x00, m0)
    8167
                mstore(0x20, m1)
    8168
                mstore(0x40, m2)
    8169
                mstore(0x60, m3)
    8170
                mstore(0x80, m4)
    8171
            }
    8172
        }
    8173
    
                                                    
                                                
    8174
        function log(uint256 p0, address p1, address p2, bool p3) internal pure {
    8175
            bytes32 m0;
    8176
            bytes32 m1;
    8177
            bytes32 m2;
    8178
            bytes32 m3;
    8179
            bytes32 m4;
    8180
            /// @solidity memory-safe-assembly
    8181
            assembly {
    8182
                m0 := mload(0x00)
    8183
                m1 := mload(0x20)
    8184
                m2 := mload(0x40)
    8185
                m3 := mload(0x60)
    8186
                m4 := mload(0x80)
    8187
                // Selector of `log(uint256,address,address,bool)`.
    8188
                mstore(0x00, 0x091ffaf5)
    8189
                mstore(0x20, p0)
    8190
                mstore(0x40, p1)
    8191
                mstore(0x60, p2)
    8192
                mstore(0x80, p3)
    8193
            }
    8194
            _sendLogPayload(0x1c, 0x84);
    8195
            /// @solidity memory-safe-assembly
    8196
            assembly {
    8197
                mstore(0x00, m0)
    8198
                mstore(0x20, m1)
    8199
                mstore(0x40, m2)
    8200
                mstore(0x60, m3)
    8201
                mstore(0x80, m4)
    8202
            }
    8203
        }
    8204
    
                                                    
                                                
    8205
        function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
    8206
            bytes32 m0;
    8207
            bytes32 m1;
    8208
            bytes32 m2;
    8209
            bytes32 m3;
    8210
            bytes32 m4;
    8211
            /// @solidity memory-safe-assembly
    8212
            assembly {
    8213
                m0 := mload(0x00)
    8214
                m1 := mload(0x20)
    8215
                m2 := mload(0x40)
    8216
                m3 := mload(0x60)
    8217
                m4 := mload(0x80)
    8218
                // Selector of `log(uint256,address,address,uint256)`.
    8219
                mstore(0x00, 0x736efbb6)
    8220
                mstore(0x20, p0)
    8221
                mstore(0x40, p1)
    8222
                mstore(0x60, p2)
    8223
                mstore(0x80, p3)
    8224
            }
    8225
            _sendLogPayload(0x1c, 0x84);
    8226
            /// @solidity memory-safe-assembly
    8227
            assembly {
    8228
                mstore(0x00, m0)
    8229
                mstore(0x20, m1)
    8230
                mstore(0x40, m2)
    8231
                mstore(0x60, m3)
    8232
                mstore(0x80, m4)
    8233
            }
    8234
        }
    8235
    
                                                    
                                                
    8236
        function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {
    8237
            bytes32 m0;
    8238
            bytes32 m1;
    8239
            bytes32 m2;
    8240
            bytes32 m3;
    8241
            bytes32 m4;
    8242
            bytes32 m5;
    8243
            bytes32 m6;
    8244
            /// @solidity memory-safe-assembly
    8245
            assembly {
    8246
                function writeString(pos, w) {
    8247
                    let length := 0
    8248
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8249
                    mstore(pos, length)
    8250
                    let shift := sub(256, shl(3, length))
    8251
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8252
                }
    8253
                m0 := mload(0x00)
    8254
                m1 := mload(0x20)
    8255
                m2 := mload(0x40)
    8256
                m3 := mload(0x60)
    8257
                m4 := mload(0x80)
    8258
                m5 := mload(0xa0)
    8259
                m6 := mload(0xc0)
    8260
                // Selector of `log(uint256,address,address,string)`.
    8261
                mstore(0x00, 0x031c6f73)
    8262
                mstore(0x20, p0)
    8263
                mstore(0x40, p1)
    8264
                mstore(0x60, p2)
    8265
                mstore(0x80, 0x80)
    8266
                writeString(0xa0, p3)
    8267
            }
    8268
            _sendLogPayload(0x1c, 0xc4);
    8269
            /// @solidity memory-safe-assembly
    8270
            assembly {
    8271
                mstore(0x00, m0)
    8272
                mstore(0x20, m1)
    8273
                mstore(0x40, m2)
    8274
                mstore(0x60, m3)
    8275
                mstore(0x80, m4)
    8276
                mstore(0xa0, m5)
    8277
                mstore(0xc0, m6)
    8278
            }
    8279
        }
    8280
    
                                                    
                                                
    8281
        function log(uint256 p0, address p1, bool p2, address p3) internal pure {
    8282
            bytes32 m0;
    8283
            bytes32 m1;
    8284
            bytes32 m2;
    8285
            bytes32 m3;
    8286
            bytes32 m4;
    8287
            /// @solidity memory-safe-assembly
    8288
            assembly {
    8289
                m0 := mload(0x00)
    8290
                m1 := mload(0x20)
    8291
                m2 := mload(0x40)
    8292
                m3 := mload(0x60)
    8293
                m4 := mload(0x80)
    8294
                // Selector of `log(uint256,address,bool,address)`.
    8295
                mstore(0x00, 0xef72c513)
    8296
                mstore(0x20, p0)
    8297
                mstore(0x40, p1)
    8298
                mstore(0x60, p2)
    8299
                mstore(0x80, p3)
    8300
            }
    8301
            _sendLogPayload(0x1c, 0x84);
    8302
            /// @solidity memory-safe-assembly
    8303
            assembly {
    8304
                mstore(0x00, m0)
    8305
                mstore(0x20, m1)
    8306
                mstore(0x40, m2)
    8307
                mstore(0x60, m3)
    8308
                mstore(0x80, m4)
    8309
            }
    8310
        }
    8311
    
                                                    
                                                
    8312
        function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
    8313
            bytes32 m0;
    8314
            bytes32 m1;
    8315
            bytes32 m2;
    8316
            bytes32 m3;
    8317
            bytes32 m4;
    8318
            /// @solidity memory-safe-assembly
    8319
            assembly {
    8320
                m0 := mload(0x00)
    8321
                m1 := mload(0x20)
    8322
                m2 := mload(0x40)
    8323
                m3 := mload(0x60)
    8324
                m4 := mload(0x80)
    8325
                // Selector of `log(uint256,address,bool,bool)`.
    8326
                mstore(0x00, 0xe351140f)
    8327
                mstore(0x20, p0)
    8328
                mstore(0x40, p1)
    8329
                mstore(0x60, p2)
    8330
                mstore(0x80, p3)
    8331
            }
    8332
            _sendLogPayload(0x1c, 0x84);
    8333
            /// @solidity memory-safe-assembly
    8334
            assembly {
    8335
                mstore(0x00, m0)
    8336
                mstore(0x20, m1)
    8337
                mstore(0x40, m2)
    8338
                mstore(0x60, m3)
    8339
                mstore(0x80, m4)
    8340
            }
    8341
        }
    8342
    
                                                    
                                                
    8343
        function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
    8344
            bytes32 m0;
    8345
            bytes32 m1;
    8346
            bytes32 m2;
    8347
            bytes32 m3;
    8348
            bytes32 m4;
    8349
            /// @solidity memory-safe-assembly
    8350
            assembly {
    8351
                m0 := mload(0x00)
    8352
                m1 := mload(0x20)
    8353
                m2 := mload(0x40)
    8354
                m3 := mload(0x60)
    8355
                m4 := mload(0x80)
    8356
                // Selector of `log(uint256,address,bool,uint256)`.
    8357
                mstore(0x00, 0x5abd992a)
    8358
                mstore(0x20, p0)
    8359
                mstore(0x40, p1)
    8360
                mstore(0x60, p2)
    8361
                mstore(0x80, p3)
    8362
            }
    8363
            _sendLogPayload(0x1c, 0x84);
    8364
            /// @solidity memory-safe-assembly
    8365
            assembly {
    8366
                mstore(0x00, m0)
    8367
                mstore(0x20, m1)
    8368
                mstore(0x40, m2)
    8369
                mstore(0x60, m3)
    8370
                mstore(0x80, m4)
    8371
            }
    8372
        }
    8373
    
                                                    
                                                
    8374
        function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {
    8375
            bytes32 m0;
    8376
            bytes32 m1;
    8377
            bytes32 m2;
    8378
            bytes32 m3;
    8379
            bytes32 m4;
    8380
            bytes32 m5;
    8381
            bytes32 m6;
    8382
            /// @solidity memory-safe-assembly
    8383
            assembly {
    8384
                function writeString(pos, w) {
    8385
                    let length := 0
    8386
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8387
                    mstore(pos, length)
    8388
                    let shift := sub(256, shl(3, length))
    8389
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8390
                }
    8391
                m0 := mload(0x00)
    8392
                m1 := mload(0x20)
    8393
                m2 := mload(0x40)
    8394
                m3 := mload(0x60)
    8395
                m4 := mload(0x80)
    8396
                m5 := mload(0xa0)
    8397
                m6 := mload(0xc0)
    8398
                // Selector of `log(uint256,address,bool,string)`.
    8399
                mstore(0x00, 0x90fb06aa)
    8400
                mstore(0x20, p0)
    8401
                mstore(0x40, p1)
    8402
                mstore(0x60, p2)
    8403
                mstore(0x80, 0x80)
    8404
                writeString(0xa0, p3)
    8405
            }
    8406
            _sendLogPayload(0x1c, 0xc4);
    8407
            /// @solidity memory-safe-assembly
    8408
            assembly {
    8409
                mstore(0x00, m0)
    8410
                mstore(0x20, m1)
    8411
                mstore(0x40, m2)
    8412
                mstore(0x60, m3)
    8413
                mstore(0x80, m4)
    8414
                mstore(0xa0, m5)
    8415
                mstore(0xc0, m6)
    8416
            }
    8417
        }
    8418
    
                                                    
                                                
    8419
        function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
    8420
            bytes32 m0;
    8421
            bytes32 m1;
    8422
            bytes32 m2;
    8423
            bytes32 m3;
    8424
            bytes32 m4;
    8425
            /// @solidity memory-safe-assembly
    8426
            assembly {
    8427
                m0 := mload(0x00)
    8428
                m1 := mload(0x20)
    8429
                m2 := mload(0x40)
    8430
                m3 := mload(0x60)
    8431
                m4 := mload(0x80)
    8432
                // Selector of `log(uint256,address,uint256,address)`.
    8433
                mstore(0x00, 0x15c127b5)
    8434
                mstore(0x20, p0)
    8435
                mstore(0x40, p1)
    8436
                mstore(0x60, p2)
    8437
                mstore(0x80, p3)
    8438
            }
    8439
            _sendLogPayload(0x1c, 0x84);
    8440
            /// @solidity memory-safe-assembly
    8441
            assembly {
    8442
                mstore(0x00, m0)
    8443
                mstore(0x20, m1)
    8444
                mstore(0x40, m2)
    8445
                mstore(0x60, m3)
    8446
                mstore(0x80, m4)
    8447
            }
    8448
        }
    8449
    
                                                    
                                                
    8450
        function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
    8451
            bytes32 m0;
    8452
            bytes32 m1;
    8453
            bytes32 m2;
    8454
            bytes32 m3;
    8455
            bytes32 m4;
    8456
            /// @solidity memory-safe-assembly
    8457
            assembly {
    8458
                m0 := mload(0x00)
    8459
                m1 := mload(0x20)
    8460
                m2 := mload(0x40)
    8461
                m3 := mload(0x60)
    8462
                m4 := mload(0x80)
    8463
                // Selector of `log(uint256,address,uint256,bool)`.
    8464
                mstore(0x00, 0x5f743a7c)
    8465
                mstore(0x20, p0)
    8466
                mstore(0x40, p1)
    8467
                mstore(0x60, p2)
    8468
                mstore(0x80, p3)
    8469
            }
    8470
            _sendLogPayload(0x1c, 0x84);
    8471
            /// @solidity memory-safe-assembly
    8472
            assembly {
    8473
                mstore(0x00, m0)
    8474
                mstore(0x20, m1)
    8475
                mstore(0x40, m2)
    8476
                mstore(0x60, m3)
    8477
                mstore(0x80, m4)
    8478
            }
    8479
        }
    8480
    
                                                    
                                                
    8481
        function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
    8482
            bytes32 m0;
    8483
            bytes32 m1;
    8484
            bytes32 m2;
    8485
            bytes32 m3;
    8486
            bytes32 m4;
    8487
            /// @solidity memory-safe-assembly
    8488
            assembly {
    8489
                m0 := mload(0x00)
    8490
                m1 := mload(0x20)
    8491
                m2 := mload(0x40)
    8492
                m3 := mload(0x60)
    8493
                m4 := mload(0x80)
    8494
                // Selector of `log(uint256,address,uint256,uint256)`.
    8495
                mstore(0x00, 0x0c9cd9c1)
    8496
                mstore(0x20, p0)
    8497
                mstore(0x40, p1)
    8498
                mstore(0x60, p2)
    8499
                mstore(0x80, p3)
    8500
            }
    8501
            _sendLogPayload(0x1c, 0x84);
    8502
            /// @solidity memory-safe-assembly
    8503
            assembly {
    8504
                mstore(0x00, m0)
    8505
                mstore(0x20, m1)
    8506
                mstore(0x40, m2)
    8507
                mstore(0x60, m3)
    8508
                mstore(0x80, m4)
    8509
            }
    8510
        }
    8511
    
                                                    
                                                
    8512
        function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {
    8513
            bytes32 m0;
    8514
            bytes32 m1;
    8515
            bytes32 m2;
    8516
            bytes32 m3;
    8517
            bytes32 m4;
    8518
            bytes32 m5;
    8519
            bytes32 m6;
    8520
            /// @solidity memory-safe-assembly
    8521
            assembly {
    8522
                function writeString(pos, w) {
    8523
                    let length := 0
    8524
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8525
                    mstore(pos, length)
    8526
                    let shift := sub(256, shl(3, length))
    8527
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8528
                }
    8529
                m0 := mload(0x00)
    8530
                m1 := mload(0x20)
    8531
                m2 := mload(0x40)
    8532
                m3 := mload(0x60)
    8533
                m4 := mload(0x80)
    8534
                m5 := mload(0xa0)
    8535
                m6 := mload(0xc0)
    8536
                // Selector of `log(uint256,address,uint256,string)`.
    8537
                mstore(0x00, 0xddb06521)
    8538
                mstore(0x20, p0)
    8539
                mstore(0x40, p1)
    8540
                mstore(0x60, p2)
    8541
                mstore(0x80, 0x80)
    8542
                writeString(0xa0, p3)
    8543
            }
    8544
            _sendLogPayload(0x1c, 0xc4);
    8545
            /// @solidity memory-safe-assembly
    8546
            assembly {
    8547
                mstore(0x00, m0)
    8548
                mstore(0x20, m1)
    8549
                mstore(0x40, m2)
    8550
                mstore(0x60, m3)
    8551
                mstore(0x80, m4)
    8552
                mstore(0xa0, m5)
    8553
                mstore(0xc0, m6)
    8554
            }
    8555
        }
    8556
    
                                                    
                                                
    8557
        function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {
    8558
            bytes32 m0;
    8559
            bytes32 m1;
    8560
            bytes32 m2;
    8561
            bytes32 m3;
    8562
            bytes32 m4;
    8563
            bytes32 m5;
    8564
            bytes32 m6;
    8565
            /// @solidity memory-safe-assembly
    8566
            assembly {
    8567
                function writeString(pos, w) {
    8568
                    let length := 0
    8569
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8570
                    mstore(pos, length)
    8571
                    let shift := sub(256, shl(3, length))
    8572
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8573
                }
    8574
                m0 := mload(0x00)
    8575
                m1 := mload(0x20)
    8576
                m2 := mload(0x40)
    8577
                m3 := mload(0x60)
    8578
                m4 := mload(0x80)
    8579
                m5 := mload(0xa0)
    8580
                m6 := mload(0xc0)
    8581
                // Selector of `log(uint256,address,string,address)`.
    8582
                mstore(0x00, 0x9cba8fff)
    8583
                mstore(0x20, p0)
    8584
                mstore(0x40, p1)
    8585
                mstore(0x60, 0x80)
    8586
                mstore(0x80, p3)
    8587
                writeString(0xa0, p2)
    8588
            }
    8589
            _sendLogPayload(0x1c, 0xc4);
    8590
            /// @solidity memory-safe-assembly
    8591
            assembly {
    8592
                mstore(0x00, m0)
    8593
                mstore(0x20, m1)
    8594
                mstore(0x40, m2)
    8595
                mstore(0x60, m3)
    8596
                mstore(0x80, m4)
    8597
                mstore(0xa0, m5)
    8598
                mstore(0xc0, m6)
    8599
            }
    8600
        }
    8601
    
                                                    
                                                
    8602
        function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {
    8603
            bytes32 m0;
    8604
            bytes32 m1;
    8605
            bytes32 m2;
    8606
            bytes32 m3;
    8607
            bytes32 m4;
    8608
            bytes32 m5;
    8609
            bytes32 m6;
    8610
            /// @solidity memory-safe-assembly
    8611
            assembly {
    8612
                function writeString(pos, w) {
    8613
                    let length := 0
    8614
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8615
                    mstore(pos, length)
    8616
                    let shift := sub(256, shl(3, length))
    8617
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8618
                }
    8619
                m0 := mload(0x00)
    8620
                m1 := mload(0x20)
    8621
                m2 := mload(0x40)
    8622
                m3 := mload(0x60)
    8623
                m4 := mload(0x80)
    8624
                m5 := mload(0xa0)
    8625
                m6 := mload(0xc0)
    8626
                // Selector of `log(uint256,address,string,bool)`.
    8627
                mstore(0x00, 0xcc32ab07)
    8628
                mstore(0x20, p0)
    8629
                mstore(0x40, p1)
    8630
                mstore(0x60, 0x80)
    8631
                mstore(0x80, p3)
    8632
                writeString(0xa0, p2)
    8633
            }
    8634
            _sendLogPayload(0x1c, 0xc4);
    8635
            /// @solidity memory-safe-assembly
    8636
            assembly {
    8637
                mstore(0x00, m0)
    8638
                mstore(0x20, m1)
    8639
                mstore(0x40, m2)
    8640
                mstore(0x60, m3)
    8641
                mstore(0x80, m4)
    8642
                mstore(0xa0, m5)
    8643
                mstore(0xc0, m6)
    8644
            }
    8645
        }
    8646
    
                                                    
                                                
    8647
        function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {
    8648
            bytes32 m0;
    8649
            bytes32 m1;
    8650
            bytes32 m2;
    8651
            bytes32 m3;
    8652
            bytes32 m4;
    8653
            bytes32 m5;
    8654
            bytes32 m6;
    8655
            /// @solidity memory-safe-assembly
    8656
            assembly {
    8657
                function writeString(pos, w) {
    8658
                    let length := 0
    8659
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8660
                    mstore(pos, length)
    8661
                    let shift := sub(256, shl(3, length))
    8662
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8663
                }
    8664
                m0 := mload(0x00)
    8665
                m1 := mload(0x20)
    8666
                m2 := mload(0x40)
    8667
                m3 := mload(0x60)
    8668
                m4 := mload(0x80)
    8669
                m5 := mload(0xa0)
    8670
                m6 := mload(0xc0)
    8671
                // Selector of `log(uint256,address,string,uint256)`.
    8672
                mstore(0x00, 0x46826b5d)
    8673
                mstore(0x20, p0)
    8674
                mstore(0x40, p1)
    8675
                mstore(0x60, 0x80)
    8676
                mstore(0x80, p3)
    8677
                writeString(0xa0, p2)
    8678
            }
    8679
            _sendLogPayload(0x1c, 0xc4);
    8680
            /// @solidity memory-safe-assembly
    8681
            assembly {
    8682
                mstore(0x00, m0)
    8683
                mstore(0x20, m1)
    8684
                mstore(0x40, m2)
    8685
                mstore(0x60, m3)
    8686
                mstore(0x80, m4)
    8687
                mstore(0xa0, m5)
    8688
                mstore(0xc0, m6)
    8689
            }
    8690
        }
    8691
    
                                                    
                                                
    8692
        function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    8693
            bytes32 m0;
    8694
            bytes32 m1;
    8695
            bytes32 m2;
    8696
            bytes32 m3;
    8697
            bytes32 m4;
    8698
            bytes32 m5;
    8699
            bytes32 m6;
    8700
            bytes32 m7;
    8701
            bytes32 m8;
    8702
            /// @solidity memory-safe-assembly
    8703
            assembly {
    8704
                function writeString(pos, w) {
    8705
                    let length := 0
    8706
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8707
                    mstore(pos, length)
    8708
                    let shift := sub(256, shl(3, length))
    8709
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8710
                }
    8711
                m0 := mload(0x00)
    8712
                m1 := mload(0x20)
    8713
                m2 := mload(0x40)
    8714
                m3 := mload(0x60)
    8715
                m4 := mload(0x80)
    8716
                m5 := mload(0xa0)
    8717
                m6 := mload(0xc0)
    8718
                m7 := mload(0xe0)
    8719
                m8 := mload(0x100)
    8720
                // Selector of `log(uint256,address,string,string)`.
    8721
                mstore(0x00, 0x3e128ca3)
    8722
                mstore(0x20, p0)
    8723
                mstore(0x40, p1)
    8724
                mstore(0x60, 0x80)
    8725
                mstore(0x80, 0xc0)
    8726
                writeString(0xa0, p2)
    8727
                writeString(0xe0, p3)
    8728
            }
    8729
            _sendLogPayload(0x1c, 0x104);
    8730
            /// @solidity memory-safe-assembly
    8731
            assembly {
    8732
                mstore(0x00, m0)
    8733
                mstore(0x20, m1)
    8734
                mstore(0x40, m2)
    8735
                mstore(0x60, m3)
    8736
                mstore(0x80, m4)
    8737
                mstore(0xa0, m5)
    8738
                mstore(0xc0, m6)
    8739
                mstore(0xe0, m7)
    8740
                mstore(0x100, m8)
    8741
            }
    8742
        }
    8743
    
                                                    
                                                
    8744
        function log(uint256 p0, bool p1, address p2, address p3) internal pure {
    8745
            bytes32 m0;
    8746
            bytes32 m1;
    8747
            bytes32 m2;
    8748
            bytes32 m3;
    8749
            bytes32 m4;
    8750
            /// @solidity memory-safe-assembly
    8751
            assembly {
    8752
                m0 := mload(0x00)
    8753
                m1 := mload(0x20)
    8754
                m2 := mload(0x40)
    8755
                m3 := mload(0x60)
    8756
                m4 := mload(0x80)
    8757
                // Selector of `log(uint256,bool,address,address)`.
    8758
                mstore(0x00, 0xa1ef4cbb)
    8759
                mstore(0x20, p0)
    8760
                mstore(0x40, p1)
    8761
                mstore(0x60, p2)
    8762
                mstore(0x80, p3)
    8763
            }
    8764
            _sendLogPayload(0x1c, 0x84);
    8765
            /// @solidity memory-safe-assembly
    8766
            assembly {
    8767
                mstore(0x00, m0)
    8768
                mstore(0x20, m1)
    8769
                mstore(0x40, m2)
    8770
                mstore(0x60, m3)
    8771
                mstore(0x80, m4)
    8772
            }
    8773
        }
    8774
    
                                                    
                                                
    8775
        function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
    8776
            bytes32 m0;
    8777
            bytes32 m1;
    8778
            bytes32 m2;
    8779
            bytes32 m3;
    8780
            bytes32 m4;
    8781
            /// @solidity memory-safe-assembly
    8782
            assembly {
    8783
                m0 := mload(0x00)
    8784
                m1 := mload(0x20)
    8785
                m2 := mload(0x40)
    8786
                m3 := mload(0x60)
    8787
                m4 := mload(0x80)
    8788
                // Selector of `log(uint256,bool,address,bool)`.
    8789
                mstore(0x00, 0x454d54a5)
    8790
                mstore(0x20, p0)
    8791
                mstore(0x40, p1)
    8792
                mstore(0x60, p2)
    8793
                mstore(0x80, p3)
    8794
            }
    8795
            _sendLogPayload(0x1c, 0x84);
    8796
            /// @solidity memory-safe-assembly
    8797
            assembly {
    8798
                mstore(0x00, m0)
    8799
                mstore(0x20, m1)
    8800
                mstore(0x40, m2)
    8801
                mstore(0x60, m3)
    8802
                mstore(0x80, m4)
    8803
            }
    8804
        }
    8805
    
                                                    
                                                
    8806
        function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
    8807
            bytes32 m0;
    8808
            bytes32 m1;
    8809
            bytes32 m2;
    8810
            bytes32 m3;
    8811
            bytes32 m4;
    8812
            /// @solidity memory-safe-assembly
    8813
            assembly {
    8814
                m0 := mload(0x00)
    8815
                m1 := mload(0x20)
    8816
                m2 := mload(0x40)
    8817
                m3 := mload(0x60)
    8818
                m4 := mload(0x80)
    8819
                // Selector of `log(uint256,bool,address,uint256)`.
    8820
                mstore(0x00, 0x078287f5)
    8821
                mstore(0x20, p0)
    8822
                mstore(0x40, p1)
    8823
                mstore(0x60, p2)
    8824
                mstore(0x80, p3)
    8825
            }
    8826
            _sendLogPayload(0x1c, 0x84);
    8827
            /// @solidity memory-safe-assembly
    8828
            assembly {
    8829
                mstore(0x00, m0)
    8830
                mstore(0x20, m1)
    8831
                mstore(0x40, m2)
    8832
                mstore(0x60, m3)
    8833
                mstore(0x80, m4)
    8834
            }
    8835
        }
    8836
    
                                                    
                                                
    8837
        function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {
    8838
            bytes32 m0;
    8839
            bytes32 m1;
    8840
            bytes32 m2;
    8841
            bytes32 m3;
    8842
            bytes32 m4;
    8843
            bytes32 m5;
    8844
            bytes32 m6;
    8845
            /// @solidity memory-safe-assembly
    8846
            assembly {
    8847
                function writeString(pos, w) {
    8848
                    let length := 0
    8849
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8850
                    mstore(pos, length)
    8851
                    let shift := sub(256, shl(3, length))
    8852
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8853
                }
    8854
                m0 := mload(0x00)
    8855
                m1 := mload(0x20)
    8856
                m2 := mload(0x40)
    8857
                m3 := mload(0x60)
    8858
                m4 := mload(0x80)
    8859
                m5 := mload(0xa0)
    8860
                m6 := mload(0xc0)
    8861
                // Selector of `log(uint256,bool,address,string)`.
    8862
                mstore(0x00, 0xade052c7)
    8863
                mstore(0x20, p0)
    8864
                mstore(0x40, p1)
    8865
                mstore(0x60, p2)
    8866
                mstore(0x80, 0x80)
    8867
                writeString(0xa0, p3)
    8868
            }
    8869
            _sendLogPayload(0x1c, 0xc4);
    8870
            /// @solidity memory-safe-assembly
    8871
            assembly {
    8872
                mstore(0x00, m0)
    8873
                mstore(0x20, m1)
    8874
                mstore(0x40, m2)
    8875
                mstore(0x60, m3)
    8876
                mstore(0x80, m4)
    8877
                mstore(0xa0, m5)
    8878
                mstore(0xc0, m6)
    8879
            }
    8880
        }
    8881
    
                                                    
                                                
    8882
        function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
    8883
            bytes32 m0;
    8884
            bytes32 m1;
    8885
            bytes32 m2;
    8886
            bytes32 m3;
    8887
            bytes32 m4;
    8888
            /// @solidity memory-safe-assembly
    8889
            assembly {
    8890
                m0 := mload(0x00)
    8891
                m1 := mload(0x20)
    8892
                m2 := mload(0x40)
    8893
                m3 := mload(0x60)
    8894
                m4 := mload(0x80)
    8895
                // Selector of `log(uint256,bool,bool,address)`.
    8896
                mstore(0x00, 0x69640b59)
    8897
                mstore(0x20, p0)
    8898
                mstore(0x40, p1)
    8899
                mstore(0x60, p2)
    8900
                mstore(0x80, p3)
    8901
            }
    8902
            _sendLogPayload(0x1c, 0x84);
    8903
            /// @solidity memory-safe-assembly
    8904
            assembly {
    8905
                mstore(0x00, m0)
    8906
                mstore(0x20, m1)
    8907
                mstore(0x40, m2)
    8908
                mstore(0x60, m3)
    8909
                mstore(0x80, m4)
    8910
            }
    8911
        }
    8912
    
                                                    
                                                
    8913
        function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
    8914
            bytes32 m0;
    8915
            bytes32 m1;
    8916
            bytes32 m2;
    8917
            bytes32 m3;
    8918
            bytes32 m4;
    8919
            /// @solidity memory-safe-assembly
    8920
            assembly {
    8921
                m0 := mload(0x00)
    8922
                m1 := mload(0x20)
    8923
                m2 := mload(0x40)
    8924
                m3 := mload(0x60)
    8925
                m4 := mload(0x80)
    8926
                // Selector of `log(uint256,bool,bool,bool)`.
    8927
                mstore(0x00, 0xb6f577a1)
    8928
                mstore(0x20, p0)
    8929
                mstore(0x40, p1)
    8930
                mstore(0x60, p2)
    8931
                mstore(0x80, p3)
    8932
            }
    8933
            _sendLogPayload(0x1c, 0x84);
    8934
            /// @solidity memory-safe-assembly
    8935
            assembly {
    8936
                mstore(0x00, m0)
    8937
                mstore(0x20, m1)
    8938
                mstore(0x40, m2)
    8939
                mstore(0x60, m3)
    8940
                mstore(0x80, m4)
    8941
            }
    8942
        }
    8943
    
                                                    
                                                
    8944
        function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
    8945
            bytes32 m0;
    8946
            bytes32 m1;
    8947
            bytes32 m2;
    8948
            bytes32 m3;
    8949
            bytes32 m4;
    8950
            /// @solidity memory-safe-assembly
    8951
            assembly {
    8952
                m0 := mload(0x00)
    8953
                m1 := mload(0x20)
    8954
                m2 := mload(0x40)
    8955
                m3 := mload(0x60)
    8956
                m4 := mload(0x80)
    8957
                // Selector of `log(uint256,bool,bool,uint256)`.
    8958
                mstore(0x00, 0x7464ce23)
    8959
                mstore(0x20, p0)
    8960
                mstore(0x40, p1)
    8961
                mstore(0x60, p2)
    8962
                mstore(0x80, p3)
    8963
            }
    8964
            _sendLogPayload(0x1c, 0x84);
    8965
            /// @solidity memory-safe-assembly
    8966
            assembly {
    8967
                mstore(0x00, m0)
    8968
                mstore(0x20, m1)
    8969
                mstore(0x40, m2)
    8970
                mstore(0x60, m3)
    8971
                mstore(0x80, m4)
    8972
            }
    8973
        }
    8974
    
                                                    
                                                
    8975
        function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {
    8976
            bytes32 m0;
    8977
            bytes32 m1;
    8978
            bytes32 m2;
    8979
            bytes32 m3;
    8980
            bytes32 m4;
    8981
            bytes32 m5;
    8982
            bytes32 m6;
    8983
            /// @solidity memory-safe-assembly
    8984
            assembly {
    8985
                function writeString(pos, w) {
    8986
                    let length := 0
    8987
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8988
                    mstore(pos, length)
    8989
                    let shift := sub(256, shl(3, length))
    8990
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8991
                }
    8992
                m0 := mload(0x00)
    8993
                m1 := mload(0x20)
    8994
                m2 := mload(0x40)
    8995
                m3 := mload(0x60)
    8996
                m4 := mload(0x80)
    8997
                m5 := mload(0xa0)
    8998
                m6 := mload(0xc0)
    8999
                // Selector of `log(uint256,bool,bool,string)`.
    9000
                mstore(0x00, 0xdddb9561)
    9001
                mstore(0x20, p0)
    9002
                mstore(0x40, p1)
    9003
                mstore(0x60, p2)
    9004
                mstore(0x80, 0x80)
    9005
                writeString(0xa0, p3)
    9006
            }
    9007
            _sendLogPayload(0x1c, 0xc4);
    9008
            /// @solidity memory-safe-assembly
    9009
            assembly {
    9010
                mstore(0x00, m0)
    9011
                mstore(0x20, m1)
    9012
                mstore(0x40, m2)
    9013
                mstore(0x60, m3)
    9014
                mstore(0x80, m4)
    9015
                mstore(0xa0, m5)
    9016
                mstore(0xc0, m6)
    9017
            }
    9018
        }
    9019
    
                                                    
                                                
    9020
        function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
    9021
            bytes32 m0;
    9022
            bytes32 m1;
    9023
            bytes32 m2;
    9024
            bytes32 m3;
    9025
            bytes32 m4;
    9026
            /// @solidity memory-safe-assembly
    9027
            assembly {
    9028
                m0 := mload(0x00)
    9029
                m1 := mload(0x20)
    9030
                m2 := mload(0x40)
    9031
                m3 := mload(0x60)
    9032
                m4 := mload(0x80)
    9033
                // Selector of `log(uint256,bool,uint256,address)`.
    9034
                mstore(0x00, 0x88cb6041)
    9035
                mstore(0x20, p0)
    9036
                mstore(0x40, p1)
    9037
                mstore(0x60, p2)
    9038
                mstore(0x80, p3)
    9039
            }
    9040
            _sendLogPayload(0x1c, 0x84);
    9041
            /// @solidity memory-safe-assembly
    9042
            assembly {
    9043
                mstore(0x00, m0)
    9044
                mstore(0x20, m1)
    9045
                mstore(0x40, m2)
    9046
                mstore(0x60, m3)
    9047
                mstore(0x80, m4)
    9048
            }
    9049
        }
    9050
    
                                                    
                                                
    9051
        function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
    9052
            bytes32 m0;
    9053
            bytes32 m1;
    9054
            bytes32 m2;
    9055
            bytes32 m3;
    9056
            bytes32 m4;
    9057
            /// @solidity memory-safe-assembly
    9058
            assembly {
    9059
                m0 := mload(0x00)
    9060
                m1 := mload(0x20)
    9061
                m2 := mload(0x40)
    9062
                m3 := mload(0x60)
    9063
                m4 := mload(0x80)
    9064
                // Selector of `log(uint256,bool,uint256,bool)`.
    9065
                mstore(0x00, 0x91a02e2a)
    9066
                mstore(0x20, p0)
    9067
                mstore(0x40, p1)
    9068
                mstore(0x60, p2)
    9069
                mstore(0x80, p3)
    9070
            }
    9071
            _sendLogPayload(0x1c, 0x84);
    9072
            /// @solidity memory-safe-assembly
    9073
            assembly {
    9074
                mstore(0x00, m0)
    9075
                mstore(0x20, m1)
    9076
                mstore(0x40, m2)
    9077
                mstore(0x60, m3)
    9078
                mstore(0x80, m4)
    9079
            }
    9080
        }
    9081
    
                                                    
                                                
    9082
        function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
    9083
            bytes32 m0;
    9084
            bytes32 m1;
    9085
            bytes32 m2;
    9086
            bytes32 m3;
    9087
            bytes32 m4;
    9088
            /// @solidity memory-safe-assembly
    9089
            assembly {
    9090
                m0 := mload(0x00)
    9091
                m1 := mload(0x20)
    9092
                m2 := mload(0x40)
    9093
                m3 := mload(0x60)
    9094
                m4 := mload(0x80)
    9095
                // Selector of `log(uint256,bool,uint256,uint256)`.
    9096
                mstore(0x00, 0xc6acc7a8)
    9097
                mstore(0x20, p0)
    9098
                mstore(0x40, p1)
    9099
                mstore(0x60, p2)
    9100
                mstore(0x80, p3)
    9101
            }
    9102
            _sendLogPayload(0x1c, 0x84);
    9103
            /// @solidity memory-safe-assembly
    9104
            assembly {
    9105
                mstore(0x00, m0)
    9106
                mstore(0x20, m1)
    9107
                mstore(0x40, m2)
    9108
                mstore(0x60, m3)
    9109
                mstore(0x80, m4)
    9110
            }
    9111
        }
    9112
    
                                                    
                                                
    9113
        function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    9114
            bytes32 m0;
    9115
            bytes32 m1;
    9116
            bytes32 m2;
    9117
            bytes32 m3;
    9118
            bytes32 m4;
    9119
            bytes32 m5;
    9120
            bytes32 m6;
    9121
            /// @solidity memory-safe-assembly
    9122
            assembly {
    9123
                function writeString(pos, w) {
    9124
                    let length := 0
    9125
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9126
                    mstore(pos, length)
    9127
                    let shift := sub(256, shl(3, length))
    9128
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9129
                }
    9130
                m0 := mload(0x00)
    9131
                m1 := mload(0x20)
    9132
                m2 := mload(0x40)
    9133
                m3 := mload(0x60)
    9134
                m4 := mload(0x80)
    9135
                m5 := mload(0xa0)
    9136
                m6 := mload(0xc0)
    9137
                // Selector of `log(uint256,bool,uint256,string)`.
    9138
                mstore(0x00, 0xde03e774)
    9139
                mstore(0x20, p0)
    9140
                mstore(0x40, p1)
    9141
                mstore(0x60, p2)
    9142
                mstore(0x80, 0x80)
    9143
                writeString(0xa0, p3)
    9144
            }
    9145
            _sendLogPayload(0x1c, 0xc4);
    9146
            /// @solidity memory-safe-assembly
    9147
            assembly {
    9148
                mstore(0x00, m0)
    9149
                mstore(0x20, m1)
    9150
                mstore(0x40, m2)
    9151
                mstore(0x60, m3)
    9152
                mstore(0x80, m4)
    9153
                mstore(0xa0, m5)
    9154
                mstore(0xc0, m6)
    9155
            }
    9156
        }
    9157
    
                                                    
                                                
    9158
        function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {
    9159
            bytes32 m0;
    9160
            bytes32 m1;
    9161
            bytes32 m2;
    9162
            bytes32 m3;
    9163
            bytes32 m4;
    9164
            bytes32 m5;
    9165
            bytes32 m6;
    9166
            /// @solidity memory-safe-assembly
    9167
            assembly {
    9168
                function writeString(pos, w) {
    9169
                    let length := 0
    9170
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9171
                    mstore(pos, length)
    9172
                    let shift := sub(256, shl(3, length))
    9173
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9174
                }
    9175
                m0 := mload(0x00)
    9176
                m1 := mload(0x20)
    9177
                m2 := mload(0x40)
    9178
                m3 := mload(0x60)
    9179
                m4 := mload(0x80)
    9180
                m5 := mload(0xa0)
    9181
                m6 := mload(0xc0)
    9182
                // Selector of `log(uint256,bool,string,address)`.
    9183
                mstore(0x00, 0xef529018)
    9184
                mstore(0x20, p0)
    9185
                mstore(0x40, p1)
    9186
                mstore(0x60, 0x80)
    9187
                mstore(0x80, p3)
    9188
                writeString(0xa0, p2)
    9189
            }
    9190
            _sendLogPayload(0x1c, 0xc4);
    9191
            /// @solidity memory-safe-assembly
    9192
            assembly {
    9193
                mstore(0x00, m0)
    9194
                mstore(0x20, m1)
    9195
                mstore(0x40, m2)
    9196
                mstore(0x60, m3)
    9197
                mstore(0x80, m4)
    9198
                mstore(0xa0, m5)
    9199
                mstore(0xc0, m6)
    9200
            }
    9201
        }
    9202
    
                                                    
                                                
    9203
        function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {
    9204
            bytes32 m0;
    9205
            bytes32 m1;
    9206
            bytes32 m2;
    9207
            bytes32 m3;
    9208
            bytes32 m4;
    9209
            bytes32 m5;
    9210
            bytes32 m6;
    9211
            /// @solidity memory-safe-assembly
    9212
            assembly {
    9213
                function writeString(pos, w) {
    9214
                    let length := 0
    9215
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9216
                    mstore(pos, length)
    9217
                    let shift := sub(256, shl(3, length))
    9218
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9219
                }
    9220
                m0 := mload(0x00)
    9221
                m1 := mload(0x20)
    9222
                m2 := mload(0x40)
    9223
                m3 := mload(0x60)
    9224
                m4 := mload(0x80)
    9225
                m5 := mload(0xa0)
    9226
                m6 := mload(0xc0)
    9227
                // Selector of `log(uint256,bool,string,bool)`.
    9228
                mstore(0x00, 0xeb928d7f)
    9229
                mstore(0x20, p0)
    9230
                mstore(0x40, p1)
    9231
                mstore(0x60, 0x80)
    9232
                mstore(0x80, p3)
    9233
                writeString(0xa0, p2)
    9234
            }
    9235
            _sendLogPayload(0x1c, 0xc4);
    9236
            /// @solidity memory-safe-assembly
    9237
            assembly {
    9238
                mstore(0x00, m0)
    9239
                mstore(0x20, m1)
    9240
                mstore(0x40, m2)
    9241
                mstore(0x60, m3)
    9242
                mstore(0x80, m4)
    9243
                mstore(0xa0, m5)
    9244
                mstore(0xc0, m6)
    9245
            }
    9246
        }
    9247
    
                                                    
                                                
    9248
        function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    9249
            bytes32 m0;
    9250
            bytes32 m1;
    9251
            bytes32 m2;
    9252
            bytes32 m3;
    9253
            bytes32 m4;
    9254
            bytes32 m5;
    9255
            bytes32 m6;
    9256
            /// @solidity memory-safe-assembly
    9257
            assembly {
    9258
                function writeString(pos, w) {
    9259
                    let length := 0
    9260
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9261
                    mstore(pos, length)
    9262
                    let shift := sub(256, shl(3, length))
    9263
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9264
                }
    9265
                m0 := mload(0x00)
    9266
                m1 := mload(0x20)
    9267
                m2 := mload(0x40)
    9268
                m3 := mload(0x60)
    9269
                m4 := mload(0x80)
    9270
                m5 := mload(0xa0)
    9271
                m6 := mload(0xc0)
    9272
                // Selector of `log(uint256,bool,string,uint256)`.
    9273
                mstore(0x00, 0x2c1d0746)
    9274
                mstore(0x20, p0)
    9275
                mstore(0x40, p1)
    9276
                mstore(0x60, 0x80)
    9277
                mstore(0x80, p3)
    9278
                writeString(0xa0, p2)
    9279
            }
    9280
            _sendLogPayload(0x1c, 0xc4);
    9281
            /// @solidity memory-safe-assembly
    9282
            assembly {
    9283
                mstore(0x00, m0)
    9284
                mstore(0x20, m1)
    9285
                mstore(0x40, m2)
    9286
                mstore(0x60, m3)
    9287
                mstore(0x80, m4)
    9288
                mstore(0xa0, m5)
    9289
                mstore(0xc0, m6)
    9290
            }
    9291
        }
    9292
    
                                                    
                                                
    9293
        function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    9294
            bytes32 m0;
    9295
            bytes32 m1;
    9296
            bytes32 m2;
    9297
            bytes32 m3;
    9298
            bytes32 m4;
    9299
            bytes32 m5;
    9300
            bytes32 m6;
    9301
            bytes32 m7;
    9302
            bytes32 m8;
    9303
            /// @solidity memory-safe-assembly
    9304
            assembly {
    9305
                function writeString(pos, w) {
    9306
                    let length := 0
    9307
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9308
                    mstore(pos, length)
    9309
                    let shift := sub(256, shl(3, length))
    9310
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9311
                }
    9312
                m0 := mload(0x00)
    9313
                m1 := mload(0x20)
    9314
                m2 := mload(0x40)
    9315
                m3 := mload(0x60)
    9316
                m4 := mload(0x80)
    9317
                m5 := mload(0xa0)
    9318
                m6 := mload(0xc0)
    9319
                m7 := mload(0xe0)
    9320
                m8 := mload(0x100)
    9321
                // Selector of `log(uint256,bool,string,string)`.
    9322
                mstore(0x00, 0x68c8b8bd)
    9323
                mstore(0x20, p0)
    9324
                mstore(0x40, p1)
    9325
                mstore(0x60, 0x80)
    9326
                mstore(0x80, 0xc0)
    9327
                writeString(0xa0, p2)
    9328
                writeString(0xe0, p3)
    9329
            }
    9330
            _sendLogPayload(0x1c, 0x104);
    9331
            /// @solidity memory-safe-assembly
    9332
            assembly {
    9333
                mstore(0x00, m0)
    9334
                mstore(0x20, m1)
    9335
                mstore(0x40, m2)
    9336
                mstore(0x60, m3)
    9337
                mstore(0x80, m4)
    9338
                mstore(0xa0, m5)
    9339
                mstore(0xc0, m6)
    9340
                mstore(0xe0, m7)
    9341
                mstore(0x100, m8)
    9342
            }
    9343
        }
    9344
    
                                                    
                                                
    9345
        function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
    9346
            bytes32 m0;
    9347
            bytes32 m1;
    9348
            bytes32 m2;
    9349
            bytes32 m3;
    9350
            bytes32 m4;
    9351
            /// @solidity memory-safe-assembly
    9352
            assembly {
    9353
                m0 := mload(0x00)
    9354
                m1 := mload(0x20)
    9355
                m2 := mload(0x40)
    9356
                m3 := mload(0x60)
    9357
                m4 := mload(0x80)
    9358
                // Selector of `log(uint256,uint256,address,address)`.
    9359
                mstore(0x00, 0x56a5d1b1)
    9360
                mstore(0x20, p0)
    9361
                mstore(0x40, p1)
    9362
                mstore(0x60, p2)
    9363
                mstore(0x80, p3)
    9364
            }
    9365
            _sendLogPayload(0x1c, 0x84);
    9366
            /// @solidity memory-safe-assembly
    9367
            assembly {
    9368
                mstore(0x00, m0)
    9369
                mstore(0x20, m1)
    9370
                mstore(0x40, m2)
    9371
                mstore(0x60, m3)
    9372
                mstore(0x80, m4)
    9373
            }
    9374
        }
    9375
    
                                                    
                                                
    9376
        function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
    9377
            bytes32 m0;
    9378
            bytes32 m1;
    9379
            bytes32 m2;
    9380
            bytes32 m3;
    9381
            bytes32 m4;
    9382
            /// @solidity memory-safe-assembly
    9383
            assembly {
    9384
                m0 := mload(0x00)
    9385
                m1 := mload(0x20)
    9386
                m2 := mload(0x40)
    9387
                m3 := mload(0x60)
    9388
                m4 := mload(0x80)
    9389
                // Selector of `log(uint256,uint256,address,bool)`.
    9390
                mstore(0x00, 0x15cac476)
    9391
                mstore(0x20, p0)
    9392
                mstore(0x40, p1)
    9393
                mstore(0x60, p2)
    9394
                mstore(0x80, p3)
    9395
            }
    9396
            _sendLogPayload(0x1c, 0x84);
    9397
            /// @solidity memory-safe-assembly
    9398
            assembly {
    9399
                mstore(0x00, m0)
    9400
                mstore(0x20, m1)
    9401
                mstore(0x40, m2)
    9402
                mstore(0x60, m3)
    9403
                mstore(0x80, m4)
    9404
            }
    9405
        }
    9406
    
                                                    
                                                
    9407
        function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
    9408
            bytes32 m0;
    9409
            bytes32 m1;
    9410
            bytes32 m2;
    9411
            bytes32 m3;
    9412
            bytes32 m4;
    9413
            /// @solidity memory-safe-assembly
    9414
            assembly {
    9415
                m0 := mload(0x00)
    9416
                m1 := mload(0x20)
    9417
                m2 := mload(0x40)
    9418
                m3 := mload(0x60)
    9419
                m4 := mload(0x80)
    9420
                // Selector of `log(uint256,uint256,address,uint256)`.
    9421
                mstore(0x00, 0x88f6e4b2)
    9422
                mstore(0x20, p0)
    9423
                mstore(0x40, p1)
    9424
                mstore(0x60, p2)
    9425
                mstore(0x80, p3)
    9426
            }
    9427
            _sendLogPayload(0x1c, 0x84);
    9428
            /// @solidity memory-safe-assembly
    9429
            assembly {
    9430
                mstore(0x00, m0)
    9431
                mstore(0x20, m1)
    9432
                mstore(0x40, m2)
    9433
                mstore(0x60, m3)
    9434
                mstore(0x80, m4)
    9435
            }
    9436
        }
    9437
    
                                                    
                                                
    9438
        function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {
    9439
            bytes32 m0;
    9440
            bytes32 m1;
    9441
            bytes32 m2;
    9442
            bytes32 m3;
    9443
            bytes32 m4;
    9444
            bytes32 m5;
    9445
            bytes32 m6;
    9446
            /// @solidity memory-safe-assembly
    9447
            assembly {
    9448
                function writeString(pos, w) {
    9449
                    let length := 0
    9450
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9451
                    mstore(pos, length)
    9452
                    let shift := sub(256, shl(3, length))
    9453
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9454
                }
    9455
                m0 := mload(0x00)
    9456
                m1 := mload(0x20)
    9457
                m2 := mload(0x40)
    9458
                m3 := mload(0x60)
    9459
                m4 := mload(0x80)
    9460
                m5 := mload(0xa0)
    9461
                m6 := mload(0xc0)
    9462
                // Selector of `log(uint256,uint256,address,string)`.
    9463
                mstore(0x00, 0x6cde40b8)
    9464
                mstore(0x20, p0)
    9465
                mstore(0x40, p1)
    9466
                mstore(0x60, p2)
    9467
                mstore(0x80, 0x80)
    9468
                writeString(0xa0, p3)
    9469
            }
    9470
            _sendLogPayload(0x1c, 0xc4);
    9471
            /// @solidity memory-safe-assembly
    9472
            assembly {
    9473
                mstore(0x00, m0)
    9474
                mstore(0x20, m1)
    9475
                mstore(0x40, m2)
    9476
                mstore(0x60, m3)
    9477
                mstore(0x80, m4)
    9478
                mstore(0xa0, m5)
    9479
                mstore(0xc0, m6)
    9480
            }
    9481
        }
    9482
    
                                                    
                                                
    9483
        function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
    9484
            bytes32 m0;
    9485
            bytes32 m1;
    9486
            bytes32 m2;
    9487
            bytes32 m3;
    9488
            bytes32 m4;
    9489
            /// @solidity memory-safe-assembly
    9490
            assembly {
    9491
                m0 := mload(0x00)
    9492
                m1 := mload(0x20)
    9493
                m2 := mload(0x40)
    9494
                m3 := mload(0x60)
    9495
                m4 := mload(0x80)
    9496
                // Selector of `log(uint256,uint256,bool,address)`.
    9497
                mstore(0x00, 0x9a816a83)
    9498
                mstore(0x20, p0)
    9499
                mstore(0x40, p1)
    9500
                mstore(0x60, p2)
    9501
                mstore(0x80, p3)
    9502
            }
    9503
            _sendLogPayload(0x1c, 0x84);
    9504
            /// @solidity memory-safe-assembly
    9505
            assembly {
    9506
                mstore(0x00, m0)
    9507
                mstore(0x20, m1)
    9508
                mstore(0x40, m2)
    9509
                mstore(0x60, m3)
    9510
                mstore(0x80, m4)
    9511
            }
    9512
        }
    9513
    
                                                    
                                                
    9514
        function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
    9515
            bytes32 m0;
    9516
            bytes32 m1;
    9517
            bytes32 m2;
    9518
            bytes32 m3;
    9519
            bytes32 m4;
    9520
            /// @solidity memory-safe-assembly
    9521
            assembly {
    9522
                m0 := mload(0x00)
    9523
                m1 := mload(0x20)
    9524
                m2 := mload(0x40)
    9525
                m3 := mload(0x60)
    9526
                m4 := mload(0x80)
    9527
                // Selector of `log(uint256,uint256,bool,bool)`.
    9528
                mstore(0x00, 0xab085ae6)
    9529
                mstore(0x20, p0)
    9530
                mstore(0x40, p1)
    9531
                mstore(0x60, p2)
    9532
                mstore(0x80, p3)
    9533
            }
    9534
            _sendLogPayload(0x1c, 0x84);
    9535
            /// @solidity memory-safe-assembly
    9536
            assembly {
    9537
                mstore(0x00, m0)
    9538
                mstore(0x20, m1)
    9539
                mstore(0x40, m2)
    9540
                mstore(0x60, m3)
    9541
                mstore(0x80, m4)
    9542
            }
    9543
        }
    9544
    
                                                    
                                                
    9545
        function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
    9546
            bytes32 m0;
    9547
            bytes32 m1;
    9548
            bytes32 m2;
    9549
            bytes32 m3;
    9550
            bytes32 m4;
    9551
            /// @solidity memory-safe-assembly
    9552
            assembly {
    9553
                m0 := mload(0x00)
    9554
                m1 := mload(0x20)
    9555
                m2 := mload(0x40)
    9556
                m3 := mload(0x60)
    9557
                m4 := mload(0x80)
    9558
                // Selector of `log(uint256,uint256,bool,uint256)`.
    9559
                mstore(0x00, 0xeb7f6fd2)
    9560
                mstore(0x20, p0)
    9561
                mstore(0x40, p1)
    9562
                mstore(0x60, p2)
    9563
                mstore(0x80, p3)
    9564
            }
    9565
            _sendLogPayload(0x1c, 0x84);
    9566
            /// @solidity memory-safe-assembly
    9567
            assembly {
    9568
                mstore(0x00, m0)
    9569
                mstore(0x20, m1)
    9570
                mstore(0x40, m2)
    9571
                mstore(0x60, m3)
    9572
                mstore(0x80, m4)
    9573
            }
    9574
        }
    9575
    
                                                    
                                                
    9576
        function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    9577
            bytes32 m0;
    9578
            bytes32 m1;
    9579
            bytes32 m2;
    9580
            bytes32 m3;
    9581
            bytes32 m4;
    9582
            bytes32 m5;
    9583
            bytes32 m6;
    9584
            /// @solidity memory-safe-assembly
    9585
            assembly {
    9586
                function writeString(pos, w) {
    9587
                    let length := 0
    9588
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9589
                    mstore(pos, length)
    9590
                    let shift := sub(256, shl(3, length))
    9591
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9592
                }
    9593
                m0 := mload(0x00)
    9594
                m1 := mload(0x20)
    9595
                m2 := mload(0x40)
    9596
                m3 := mload(0x60)
    9597
                m4 := mload(0x80)
    9598
                m5 := mload(0xa0)
    9599
                m6 := mload(0xc0)
    9600
                // Selector of `log(uint256,uint256,bool,string)`.
    9601
                mstore(0x00, 0xa5b4fc99)
    9602
                mstore(0x20, p0)
    9603
                mstore(0x40, p1)
    9604
                mstore(0x60, p2)
    9605
                mstore(0x80, 0x80)
    9606
                writeString(0xa0, p3)
    9607
            }
    9608
            _sendLogPayload(0x1c, 0xc4);
    9609
            /// @solidity memory-safe-assembly
    9610
            assembly {
    9611
                mstore(0x00, m0)
    9612
                mstore(0x20, m1)
    9613
                mstore(0x40, m2)
    9614
                mstore(0x60, m3)
    9615
                mstore(0x80, m4)
    9616
                mstore(0xa0, m5)
    9617
                mstore(0xc0, m6)
    9618
            }
    9619
        }
    9620
    
                                                    
                                                
    9621
        function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
    9622
            bytes32 m0;
    9623
            bytes32 m1;
    9624
            bytes32 m2;
    9625
            bytes32 m3;
    9626
            bytes32 m4;
    9627
            /// @solidity memory-safe-assembly
    9628
            assembly {
    9629
                m0 := mload(0x00)
    9630
                m1 := mload(0x20)
    9631
                m2 := mload(0x40)
    9632
                m3 := mload(0x60)
    9633
                m4 := mload(0x80)
    9634
                // Selector of `log(uint256,uint256,uint256,address)`.
    9635
                mstore(0x00, 0xfa8185af)
    9636
                mstore(0x20, p0)
    9637
                mstore(0x40, p1)
    9638
                mstore(0x60, p2)
    9639
                mstore(0x80, p3)
    9640
            }
    9641
            _sendLogPayload(0x1c, 0x84);
    9642
            /// @solidity memory-safe-assembly
    9643
            assembly {
    9644
                mstore(0x00, m0)
    9645
                mstore(0x20, m1)
    9646
                mstore(0x40, m2)
    9647
                mstore(0x60, m3)
    9648
                mstore(0x80, m4)
    9649
            }
    9650
        }
    9651
    
                                                    
                                                
    9652
        function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
    9653
            bytes32 m0;
    9654
            bytes32 m1;
    9655
            bytes32 m2;
    9656
            bytes32 m3;
    9657
            bytes32 m4;
    9658
            /// @solidity memory-safe-assembly
    9659
            assembly {
    9660
                m0 := mload(0x00)
    9661
                m1 := mload(0x20)
    9662
                m2 := mload(0x40)
    9663
                m3 := mload(0x60)
    9664
                m4 := mload(0x80)
    9665
                // Selector of `log(uint256,uint256,uint256,bool)`.
    9666
                mstore(0x00, 0xc598d185)
    9667
                mstore(0x20, p0)
    9668
                mstore(0x40, p1)
    9669
                mstore(0x60, p2)
    9670
                mstore(0x80, p3)
    9671
            }
    9672
            _sendLogPayload(0x1c, 0x84);
    9673
            /// @solidity memory-safe-assembly
    9674
            assembly {
    9675
                mstore(0x00, m0)
    9676
                mstore(0x20, m1)
    9677
                mstore(0x40, m2)
    9678
                mstore(0x60, m3)
    9679
                mstore(0x80, m4)
    9680
            }
    9681
        }
    9682
    
                                                    
                                                
    9683
        function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    9684
            bytes32 m0;
    9685
            bytes32 m1;
    9686
            bytes32 m2;
    9687
            bytes32 m3;
    9688
            bytes32 m4;
    9689
            /// @solidity memory-safe-assembly
    9690
            assembly {
    9691
                m0 := mload(0x00)
    9692
                m1 := mload(0x20)
    9693
                m2 := mload(0x40)
    9694
                m3 := mload(0x60)
    9695
                m4 := mload(0x80)
    9696
                // Selector of `log(uint256,uint256,uint256,uint256)`.
    9697
                mstore(0x00, 0x193fb800)
    9698
                mstore(0x20, p0)
    9699
                mstore(0x40, p1)
    9700
                mstore(0x60, p2)
    9701
                mstore(0x80, p3)
    9702
            }
    9703
            _sendLogPayload(0x1c, 0x84);
    9704
            /// @solidity memory-safe-assembly
    9705
            assembly {
    9706
                mstore(0x00, m0)
    9707
                mstore(0x20, m1)
    9708
                mstore(0x40, m2)
    9709
                mstore(0x60, m3)
    9710
                mstore(0x80, m4)
    9711
            }
    9712
        }
    9713
    
                                                    
                                                
    9714
        function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    9715
            bytes32 m0;
    9716
            bytes32 m1;
    9717
            bytes32 m2;
    9718
            bytes32 m3;
    9719
            bytes32 m4;
    9720
            bytes32 m5;
    9721
            bytes32 m6;
    9722
            /// @solidity memory-safe-assembly
    9723
            assembly {
    9724
                function writeString(pos, w) {
    9725
                    let length := 0
    9726
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9727
                    mstore(pos, length)
    9728
                    let shift := sub(256, shl(3, length))
    9729
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9730
                }
    9731
                m0 := mload(0x00)
    9732
                m1 := mload(0x20)
    9733
                m2 := mload(0x40)
    9734
                m3 := mload(0x60)
    9735
                m4 := mload(0x80)
    9736
                m5 := mload(0xa0)
    9737
                m6 := mload(0xc0)
    9738
                // Selector of `log(uint256,uint256,uint256,string)`.
    9739
                mstore(0x00, 0x59cfcbe3)
    9740
                mstore(0x20, p0)
    9741
                mstore(0x40, p1)
    9742
                mstore(0x60, p2)
    9743
                mstore(0x80, 0x80)
    9744
                writeString(0xa0, p3)
    9745
            }
    9746
            _sendLogPayload(0x1c, 0xc4);
    9747
            /// @solidity memory-safe-assembly
    9748
            assembly {
    9749
                mstore(0x00, m0)
    9750
                mstore(0x20, m1)
    9751
                mstore(0x40, m2)
    9752
                mstore(0x60, m3)
    9753
                mstore(0x80, m4)
    9754
                mstore(0xa0, m5)
    9755
                mstore(0xc0, m6)
    9756
            }
    9757
        }
    9758
    
                                                    
                                                
    9759
        function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {
    9760
            bytes32 m0;
    9761
            bytes32 m1;
    9762
            bytes32 m2;
    9763
            bytes32 m3;
    9764
            bytes32 m4;
    9765
            bytes32 m5;
    9766
            bytes32 m6;
    9767
            /// @solidity memory-safe-assembly
    9768
            assembly {
    9769
                function writeString(pos, w) {
    9770
                    let length := 0
    9771
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9772
                    mstore(pos, length)
    9773
                    let shift := sub(256, shl(3, length))
    9774
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9775
                }
    9776
                m0 := mload(0x00)
    9777
                m1 := mload(0x20)
    9778
                m2 := mload(0x40)
    9779
                m3 := mload(0x60)
    9780
                m4 := mload(0x80)
    9781
                m5 := mload(0xa0)
    9782
                m6 := mload(0xc0)
    9783
                // Selector of `log(uint256,uint256,string,address)`.
    9784
                mstore(0x00, 0x42d21db7)
    9785
                mstore(0x20, p0)
    9786
                mstore(0x40, p1)
    9787
                mstore(0x60, 0x80)
    9788
                mstore(0x80, p3)
    9789
                writeString(0xa0, p2)
    9790
            }
    9791
            _sendLogPayload(0x1c, 0xc4);
    9792
            /// @solidity memory-safe-assembly
    9793
            assembly {
    9794
                mstore(0x00, m0)
    9795
                mstore(0x20, m1)
    9796
                mstore(0x40, m2)
    9797
                mstore(0x60, m3)
    9798
                mstore(0x80, m4)
    9799
                mstore(0xa0, m5)
    9800
                mstore(0xc0, m6)
    9801
            }
    9802
        }
    9803
    
                                                    
                                                
    9804
        function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    9805
            bytes32 m0;
    9806
            bytes32 m1;
    9807
            bytes32 m2;
    9808
            bytes32 m3;
    9809
            bytes32 m4;
    9810
            bytes32 m5;
    9811
            bytes32 m6;
    9812
            /// @solidity memory-safe-assembly
    9813
            assembly {
    9814
                function writeString(pos, w) {
    9815
                    let length := 0
    9816
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9817
                    mstore(pos, length)
    9818
                    let shift := sub(256, shl(3, length))
    9819
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9820
                }
    9821
                m0 := mload(0x00)
    9822
                m1 := mload(0x20)
    9823
                m2 := mload(0x40)
    9824
                m3 := mload(0x60)
    9825
                m4 := mload(0x80)
    9826
                m5 := mload(0xa0)
    9827
                m6 := mload(0xc0)
    9828
                // Selector of `log(uint256,uint256,string,bool)`.
    9829
                mstore(0x00, 0x7af6ab25)
    9830
                mstore(0x20, p0)
    9831
                mstore(0x40, p1)
    9832
                mstore(0x60, 0x80)
    9833
                mstore(0x80, p3)
    9834
                writeString(0xa0, p2)
    9835
            }
    9836
            _sendLogPayload(0x1c, 0xc4);
    9837
            /// @solidity memory-safe-assembly
    9838
            assembly {
    9839
                mstore(0x00, m0)
    9840
                mstore(0x20, m1)
    9841
                mstore(0x40, m2)
    9842
                mstore(0x60, m3)
    9843
                mstore(0x80, m4)
    9844
                mstore(0xa0, m5)
    9845
                mstore(0xc0, m6)
    9846
            }
    9847
        }
    9848
    
                                                    
                                                
    9849
        function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    9850
            bytes32 m0;
    9851
            bytes32 m1;
    9852
            bytes32 m2;
    9853
            bytes32 m3;
    9854
            bytes32 m4;
    9855
            bytes32 m5;
    9856
            bytes32 m6;
    9857
            /// @solidity memory-safe-assembly
    9858
            assembly {
    9859
                function writeString(pos, w) {
    9860
                    let length := 0
    9861
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9862
                    mstore(pos, length)
    9863
                    let shift := sub(256, shl(3, length))
    9864
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9865
                }
    9866
                m0 := mload(0x00)
    9867
                m1 := mload(0x20)
    9868
                m2 := mload(0x40)
    9869
                m3 := mload(0x60)
    9870
                m4 := mload(0x80)
    9871
                m5 := mload(0xa0)
    9872
                m6 := mload(0xc0)
    9873
                // Selector of `log(uint256,uint256,string,uint256)`.
    9874
                mstore(0x00, 0x5da297eb)
    9875
                mstore(0x20, p0)
    9876
                mstore(0x40, p1)
    9877
                mstore(0x60, 0x80)
    9878
                mstore(0x80, p3)
    9879
                writeString(0xa0, p2)
    9880
            }
    9881
            _sendLogPayload(0x1c, 0xc4);
    9882
            /// @solidity memory-safe-assembly
    9883
            assembly {
    9884
                mstore(0x00, m0)
    9885
                mstore(0x20, m1)
    9886
                mstore(0x40, m2)
    9887
                mstore(0x60, m3)
    9888
                mstore(0x80, m4)
    9889
                mstore(0xa0, m5)
    9890
                mstore(0xc0, m6)
    9891
            }
    9892
        }
    9893
    
                                                    
                                                
    9894
        function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    9895
            bytes32 m0;
    9896
            bytes32 m1;
    9897
            bytes32 m2;
    9898
            bytes32 m3;
    9899
            bytes32 m4;
    9900
            bytes32 m5;
    9901
            bytes32 m6;
    9902
            bytes32 m7;
    9903
            bytes32 m8;
    9904
            /// @solidity memory-safe-assembly
    9905
            assembly {
    9906
                function writeString(pos, w) {
    9907
                    let length := 0
    9908
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9909
                    mstore(pos, length)
    9910
                    let shift := sub(256, shl(3, length))
    9911
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9912
                }
    9913
                m0 := mload(0x00)
    9914
                m1 := mload(0x20)
    9915
                m2 := mload(0x40)
    9916
                m3 := mload(0x60)
    9917
                m4 := mload(0x80)
    9918
                m5 := mload(0xa0)
    9919
                m6 := mload(0xc0)
    9920
                m7 := mload(0xe0)
    9921
                m8 := mload(0x100)
    9922
                // Selector of `log(uint256,uint256,string,string)`.
    9923
                mstore(0x00, 0x27d8afd2)
    9924
                mstore(0x20, p0)
    9925
                mstore(0x40, p1)
    9926
                mstore(0x60, 0x80)
    9927
                mstore(0x80, 0xc0)
    9928
                writeString(0xa0, p2)
    9929
                writeString(0xe0, p3)
    9930
            }
    9931
            _sendLogPayload(0x1c, 0x104);
    9932
            /// @solidity memory-safe-assembly
    9933
            assembly {
    9934
                mstore(0x00, m0)
    9935
                mstore(0x20, m1)
    9936
                mstore(0x40, m2)
    9937
                mstore(0x60, m3)
    9938
                mstore(0x80, m4)
    9939
                mstore(0xa0, m5)
    9940
                mstore(0xc0, m6)
    9941
                mstore(0xe0, m7)
    9942
                mstore(0x100, m8)
    9943
            }
    9944
        }
    9945
    
                                                    
                                                
    9946
        function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {
    9947
            bytes32 m0;
    9948
            bytes32 m1;
    9949
            bytes32 m2;
    9950
            bytes32 m3;
    9951
            bytes32 m4;
    9952
            bytes32 m5;
    9953
            bytes32 m6;
    9954
            /// @solidity memory-safe-assembly
    9955
            assembly {
    9956
                function writeString(pos, w) {
    9957
                    let length := 0
    9958
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9959
                    mstore(pos, length)
    9960
                    let shift := sub(256, shl(3, length))
    9961
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9962
                }
    9963
                m0 := mload(0x00)
    9964
                m1 := mload(0x20)
    9965
                m2 := mload(0x40)
    9966
                m3 := mload(0x60)
    9967
                m4 := mload(0x80)
    9968
                m5 := mload(0xa0)
    9969
                m6 := mload(0xc0)
    9970
                // Selector of `log(uint256,string,address,address)`.
    9971
                mstore(0x00, 0x6168ed61)
    9972
                mstore(0x20, p0)
    9973
                mstore(0x40, 0x80)
    9974
                mstore(0x60, p2)
    9975
                mstore(0x80, p3)
    9976
                writeString(0xa0, p1)
    9977
            }
    9978
            _sendLogPayload(0x1c, 0xc4);
    9979
            /// @solidity memory-safe-assembly
    9980
            assembly {
    9981
                mstore(0x00, m0)
    9982
                mstore(0x20, m1)
    9983
                mstore(0x40, m2)
    9984
                mstore(0x60, m3)
    9985
                mstore(0x80, m4)
    9986
                mstore(0xa0, m5)
    9987
                mstore(0xc0, m6)
    9988
            }
    9989
        }
    9990
    
                                                    
                                                
    9991
        function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {
    9992
            bytes32 m0;
    9993
            bytes32 m1;
    9994
            bytes32 m2;
    9995
            bytes32 m3;
    9996
            bytes32 m4;
    9997
            bytes32 m5;
    9998
            bytes32 m6;
    9999
            /// @solidity memory-safe-assembly
    10000
            assembly {
    10001
                function writeString(pos, w) {
    10002
                    let length := 0
    10003
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10004
                    mstore(pos, length)
    10005
                    let shift := sub(256, shl(3, length))
    10006
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10007
                }
    10008
                m0 := mload(0x00)
    10009
                m1 := mload(0x20)
    10010
                m2 := mload(0x40)
    10011
                m3 := mload(0x60)
    10012
                m4 := mload(0x80)
    10013
                m5 := mload(0xa0)
    10014
                m6 := mload(0xc0)
    10015
                // Selector of `log(uint256,string,address,bool)`.
    10016
                mstore(0x00, 0x90c30a56)
    10017
                mstore(0x20, p0)
    10018
                mstore(0x40, 0x80)
    10019
                mstore(0x60, p2)
    10020
                mstore(0x80, p3)
    10021
                writeString(0xa0, p1)
    10022
            }
    10023
            _sendLogPayload(0x1c, 0xc4);
    10024
            /// @solidity memory-safe-assembly
    10025
            assembly {
    10026
                mstore(0x00, m0)
    10027
                mstore(0x20, m1)
    10028
                mstore(0x40, m2)
    10029
                mstore(0x60, m3)
    10030
                mstore(0x80, m4)
    10031
                mstore(0xa0, m5)
    10032
                mstore(0xc0, m6)
    10033
            }
    10034
        }
    10035
    
                                                    
                                                
    10036
        function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {
    10037
            bytes32 m0;
    10038
            bytes32 m1;
    10039
            bytes32 m2;
    10040
            bytes32 m3;
    10041
            bytes32 m4;
    10042
            bytes32 m5;
    10043
            bytes32 m6;
    10044
            /// @solidity memory-safe-assembly
    10045
            assembly {
    10046
                function writeString(pos, w) {
    10047
                    let length := 0
    10048
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10049
                    mstore(pos, length)
    10050
                    let shift := sub(256, shl(3, length))
    10051
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10052
                }
    10053
                m0 := mload(0x00)
    10054
                m1 := mload(0x20)
    10055
                m2 := mload(0x40)
    10056
                m3 := mload(0x60)
    10057
                m4 := mload(0x80)
    10058
                m5 := mload(0xa0)
    10059
                m6 := mload(0xc0)
    10060
                // Selector of `log(uint256,string,address,uint256)`.
    10061
                mstore(0x00, 0xe8d3018d)
    10062
                mstore(0x20, p0)
    10063
                mstore(0x40, 0x80)
    10064
                mstore(0x60, p2)
    10065
                mstore(0x80, p3)
    10066
                writeString(0xa0, p1)
    10067
            }
    10068
            _sendLogPayload(0x1c, 0xc4);
    10069
            /// @solidity memory-safe-assembly
    10070
            assembly {
    10071
                mstore(0x00, m0)
    10072
                mstore(0x20, m1)
    10073
                mstore(0x40, m2)
    10074
                mstore(0x60, m3)
    10075
                mstore(0x80, m4)
    10076
                mstore(0xa0, m5)
    10077
                mstore(0xc0, m6)
    10078
            }
    10079
        }
    10080
    
                                                    
                                                
    10081
        function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    10082
            bytes32 m0;
    10083
            bytes32 m1;
    10084
            bytes32 m2;
    10085
            bytes32 m3;
    10086
            bytes32 m4;
    10087
            bytes32 m5;
    10088
            bytes32 m6;
    10089
            bytes32 m7;
    10090
            bytes32 m8;
    10091
            /// @solidity memory-safe-assembly
    10092
            assembly {
    10093
                function writeString(pos, w) {
    10094
                    let length := 0
    10095
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10096
                    mstore(pos, length)
    10097
                    let shift := sub(256, shl(3, length))
    10098
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10099
                }
    10100
                m0 := mload(0x00)
    10101
                m1 := mload(0x20)
    10102
                m2 := mload(0x40)
    10103
                m3 := mload(0x60)
    10104
                m4 := mload(0x80)
    10105
                m5 := mload(0xa0)
    10106
                m6 := mload(0xc0)
    10107
                m7 := mload(0xe0)
    10108
                m8 := mload(0x100)
    10109
                // Selector of `log(uint256,string,address,string)`.
    10110
                mstore(0x00, 0x9c3adfa1)
    10111
                mstore(0x20, p0)
    10112
                mstore(0x40, 0x80)
    10113
                mstore(0x60, p2)
    10114
                mstore(0x80, 0xc0)
    10115
                writeString(0xa0, p1)
    10116
                writeString(0xe0, p3)
    10117
            }
    10118
            _sendLogPayload(0x1c, 0x104);
    10119
            /// @solidity memory-safe-assembly
    10120
            assembly {
    10121
                mstore(0x00, m0)
    10122
                mstore(0x20, m1)
    10123
                mstore(0x40, m2)
    10124
                mstore(0x60, m3)
    10125
                mstore(0x80, m4)
    10126
                mstore(0xa0, m5)
    10127
                mstore(0xc0, m6)
    10128
                mstore(0xe0, m7)
    10129
                mstore(0x100, m8)
    10130
            }
    10131
        }
    10132
    
                                                    
                                                
    10133
        function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {
    10134
            bytes32 m0;
    10135
            bytes32 m1;
    10136
            bytes32 m2;
    10137
            bytes32 m3;
    10138
            bytes32 m4;
    10139
            bytes32 m5;
    10140
            bytes32 m6;
    10141
            /// @solidity memory-safe-assembly
    10142
            assembly {
    10143
                function writeString(pos, w) {
    10144
                    let length := 0
    10145
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10146
                    mstore(pos, length)
    10147
                    let shift := sub(256, shl(3, length))
    10148
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10149
                }
    10150
                m0 := mload(0x00)
    10151
                m1 := mload(0x20)
    10152
                m2 := mload(0x40)
    10153
                m3 := mload(0x60)
    10154
                m4 := mload(0x80)
    10155
                m5 := mload(0xa0)
    10156
                m6 := mload(0xc0)
    10157
                // Selector of `log(uint256,string,bool,address)`.
    10158
                mstore(0x00, 0xae2ec581)
    10159
                mstore(0x20, p0)
    10160
                mstore(0x40, 0x80)
    10161
                mstore(0x60, p2)
    10162
                mstore(0x80, p3)
    10163
                writeString(0xa0, p1)
    10164
            }
    10165
            _sendLogPayload(0x1c, 0xc4);
    10166
            /// @solidity memory-safe-assembly
    10167
            assembly {
    10168
                mstore(0x00, m0)
    10169
                mstore(0x20, m1)
    10170
                mstore(0x40, m2)
    10171
                mstore(0x60, m3)
    10172
                mstore(0x80, m4)
    10173
                mstore(0xa0, m5)
    10174
                mstore(0xc0, m6)
    10175
            }
    10176
        }
    10177
    
                                                    
                                                
    10178
        function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {
    10179
            bytes32 m0;
    10180
            bytes32 m1;
    10181
            bytes32 m2;
    10182
            bytes32 m3;
    10183
            bytes32 m4;
    10184
            bytes32 m5;
    10185
            bytes32 m6;
    10186
            /// @solidity memory-safe-assembly
    10187
            assembly {
    10188
                function writeString(pos, w) {
    10189
                    let length := 0
    10190
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10191
                    mstore(pos, length)
    10192
                    let shift := sub(256, shl(3, length))
    10193
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10194
                }
    10195
                m0 := mload(0x00)
    10196
                m1 := mload(0x20)
    10197
                m2 := mload(0x40)
    10198
                m3 := mload(0x60)
    10199
                m4 := mload(0x80)
    10200
                m5 := mload(0xa0)
    10201
                m6 := mload(0xc0)
    10202
                // Selector of `log(uint256,string,bool,bool)`.
    10203
                mstore(0x00, 0xba535d9c)
    10204
                mstore(0x20, p0)
    10205
                mstore(0x40, 0x80)
    10206
                mstore(0x60, p2)
    10207
                mstore(0x80, p3)
    10208
                writeString(0xa0, p1)
    10209
            }
    10210
            _sendLogPayload(0x1c, 0xc4);
    10211
            /// @solidity memory-safe-assembly
    10212
            assembly {
    10213
                mstore(0x00, m0)
    10214
                mstore(0x20, m1)
    10215
                mstore(0x40, m2)
    10216
                mstore(0x60, m3)
    10217
                mstore(0x80, m4)
    10218
                mstore(0xa0, m5)
    10219
                mstore(0xc0, m6)
    10220
            }
    10221
        }
    10222
    
                                                    
                                                
    10223
        function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    10224
            bytes32 m0;
    10225
            bytes32 m1;
    10226
            bytes32 m2;
    10227
            bytes32 m3;
    10228
            bytes32 m4;
    10229
            bytes32 m5;
    10230
            bytes32 m6;
    10231
            /// @solidity memory-safe-assembly
    10232
            assembly {
    10233
                function writeString(pos, w) {
    10234
                    let length := 0
    10235
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10236
                    mstore(pos, length)
    10237
                    let shift := sub(256, shl(3, length))
    10238
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10239
                }
    10240
                m0 := mload(0x00)
    10241
                m1 := mload(0x20)
    10242
                m2 := mload(0x40)
    10243
                m3 := mload(0x60)
    10244
                m4 := mload(0x80)
    10245
                m5 := mload(0xa0)
    10246
                m6 := mload(0xc0)
    10247
                // Selector of `log(uint256,string,bool,uint256)`.
    10248
                mstore(0x00, 0xcf009880)
    10249
                mstore(0x20, p0)
    10250
                mstore(0x40, 0x80)
    10251
                mstore(0x60, p2)
    10252
                mstore(0x80, p3)
    10253
                writeString(0xa0, p1)
    10254
            }
    10255
            _sendLogPayload(0x1c, 0xc4);
    10256
            /// @solidity memory-safe-assembly
    10257
            assembly {
    10258
                mstore(0x00, m0)
    10259
                mstore(0x20, m1)
    10260
                mstore(0x40, m2)
    10261
                mstore(0x60, m3)
    10262
                mstore(0x80, m4)
    10263
                mstore(0xa0, m5)
    10264
                mstore(0xc0, m6)
    10265
            }
    10266
        }
    10267
    
                                                    
                                                
    10268
        function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    10269
            bytes32 m0;
    10270
            bytes32 m1;
    10271
            bytes32 m2;
    10272
            bytes32 m3;
    10273
            bytes32 m4;
    10274
            bytes32 m5;
    10275
            bytes32 m6;
    10276
            bytes32 m7;
    10277
            bytes32 m8;
    10278
            /// @solidity memory-safe-assembly
    10279
            assembly {
    10280
                function writeString(pos, w) {
    10281
                    let length := 0
    10282
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10283
                    mstore(pos, length)
    10284
                    let shift := sub(256, shl(3, length))
    10285
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10286
                }
    10287
                m0 := mload(0x00)
    10288
                m1 := mload(0x20)
    10289
                m2 := mload(0x40)
    10290
                m3 := mload(0x60)
    10291
                m4 := mload(0x80)
    10292
                m5 := mload(0xa0)
    10293
                m6 := mload(0xc0)
    10294
                m7 := mload(0xe0)
    10295
                m8 := mload(0x100)
    10296
                // Selector of `log(uint256,string,bool,string)`.
    10297
                mstore(0x00, 0xd2d423cd)
    10298
                mstore(0x20, p0)
    10299
                mstore(0x40, 0x80)
    10300
                mstore(0x60, p2)
    10301
                mstore(0x80, 0xc0)
    10302
                writeString(0xa0, p1)
    10303
                writeString(0xe0, p3)
    10304
            }
    10305
            _sendLogPayload(0x1c, 0x104);
    10306
            /// @solidity memory-safe-assembly
    10307
            assembly {
    10308
                mstore(0x00, m0)
    10309
                mstore(0x20, m1)
    10310
                mstore(0x40, m2)
    10311
                mstore(0x60, m3)
    10312
                mstore(0x80, m4)
    10313
                mstore(0xa0, m5)
    10314
                mstore(0xc0, m6)
    10315
                mstore(0xe0, m7)
    10316
                mstore(0x100, m8)
    10317
            }
    10318
        }
    10319
    
                                                    
                                                
    10320
        function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {
    10321
            bytes32 m0;
    10322
            bytes32 m1;
    10323
            bytes32 m2;
    10324
            bytes32 m3;
    10325
            bytes32 m4;
    10326
            bytes32 m5;
    10327
            bytes32 m6;
    10328
            /// @solidity memory-safe-assembly
    10329
            assembly {
    10330
                function writeString(pos, w) {
    10331
                    let length := 0
    10332
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10333
                    mstore(pos, length)
    10334
                    let shift := sub(256, shl(3, length))
    10335
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10336
                }
    10337
                m0 := mload(0x00)
    10338
                m1 := mload(0x20)
    10339
                m2 := mload(0x40)
    10340
                m3 := mload(0x60)
    10341
                m4 := mload(0x80)
    10342
                m5 := mload(0xa0)
    10343
                m6 := mload(0xc0)
    10344
                // Selector of `log(uint256,string,uint256,address)`.
    10345
                mstore(0x00, 0x3b2279b4)
    10346
                mstore(0x20, p0)
    10347
                mstore(0x40, 0x80)
    10348
                mstore(0x60, p2)
    10349
                mstore(0x80, p3)
    10350
                writeString(0xa0, p1)
    10351
            }
    10352
            _sendLogPayload(0x1c, 0xc4);
    10353
            /// @solidity memory-safe-assembly
    10354
            assembly {
    10355
                mstore(0x00, m0)
    10356
                mstore(0x20, m1)
    10357
                mstore(0x40, m2)
    10358
                mstore(0x60, m3)
    10359
                mstore(0x80, m4)
    10360
                mstore(0xa0, m5)
    10361
                mstore(0xc0, m6)
    10362
            }
    10363
        }
    10364
    
                                                    
                                                
    10365
        function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    10366
            bytes32 m0;
    10367
            bytes32 m1;
    10368
            bytes32 m2;
    10369
            bytes32 m3;
    10370
            bytes32 m4;
    10371
            bytes32 m5;
    10372
            bytes32 m6;
    10373
            /// @solidity memory-safe-assembly
    10374
            assembly {
    10375
                function writeString(pos, w) {
    10376
                    let length := 0
    10377
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10378
                    mstore(pos, length)
    10379
                    let shift := sub(256, shl(3, length))
    10380
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10381
                }
    10382
                m0 := mload(0x00)
    10383
                m1 := mload(0x20)
    10384
                m2 := mload(0x40)
    10385
                m3 := mload(0x60)
    10386
                m4 := mload(0x80)
    10387
                m5 := mload(0xa0)
    10388
                m6 := mload(0xc0)
    10389
                // Selector of `log(uint256,string,uint256,bool)`.
    10390
                mstore(0x00, 0x691a8f74)
    10391
                mstore(0x20, p0)
    10392
                mstore(0x40, 0x80)
    10393
                mstore(0x60, p2)
    10394
                mstore(0x80, p3)
    10395
                writeString(0xa0, p1)
    10396
            }
    10397
            _sendLogPayload(0x1c, 0xc4);
    10398
            /// @solidity memory-safe-assembly
    10399
            assembly {
    10400
                mstore(0x00, m0)
    10401
                mstore(0x20, m1)
    10402
                mstore(0x40, m2)
    10403
                mstore(0x60, m3)
    10404
                mstore(0x80, m4)
    10405
                mstore(0xa0, m5)
    10406
                mstore(0xc0, m6)
    10407
            }
    10408
        }
    10409
    
                                                    
                                                
    10410
        function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    10411
            bytes32 m0;
    10412
            bytes32 m1;
    10413
            bytes32 m2;
    10414
            bytes32 m3;
    10415
            bytes32 m4;
    10416
            bytes32 m5;
    10417
            bytes32 m6;
    10418
            /// @solidity memory-safe-assembly
    10419
            assembly {
    10420
                function writeString(pos, w) {
    10421
                    let length := 0
    10422
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10423
                    mstore(pos, length)
    10424
                    let shift := sub(256, shl(3, length))
    10425
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10426
                }
    10427
                m0 := mload(0x00)
    10428
                m1 := mload(0x20)
    10429
                m2 := mload(0x40)
    10430
                m3 := mload(0x60)
    10431
                m4 := mload(0x80)
    10432
                m5 := mload(0xa0)
    10433
                m6 := mload(0xc0)
    10434
                // Selector of `log(uint256,string,uint256,uint256)`.
    10435
                mstore(0x00, 0x82c25b74)
    10436
                mstore(0x20, p0)
    10437
                mstore(0x40, 0x80)
    10438
                mstore(0x60, p2)
    10439
                mstore(0x80, p3)
    10440
                writeString(0xa0, p1)
    10441
            }
    10442
            _sendLogPayload(0x1c, 0xc4);
    10443
            /// @solidity memory-safe-assembly
    10444
            assembly {
    10445
                mstore(0x00, m0)
    10446
                mstore(0x20, m1)
    10447
                mstore(0x40, m2)
    10448
                mstore(0x60, m3)
    10449
                mstore(0x80, m4)
    10450
                mstore(0xa0, m5)
    10451
                mstore(0xc0, m6)
    10452
            }
    10453
        }
    10454
    
                                                    
                                                
    10455
        function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    10456
            bytes32 m0;
    10457
            bytes32 m1;
    10458
            bytes32 m2;
    10459
            bytes32 m3;
    10460
            bytes32 m4;
    10461
            bytes32 m5;
    10462
            bytes32 m6;
    10463
            bytes32 m7;
    10464
            bytes32 m8;
    10465
            /// @solidity memory-safe-assembly
    10466
            assembly {
    10467
                function writeString(pos, w) {
    10468
                    let length := 0
    10469
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10470
                    mstore(pos, length)
    10471
                    let shift := sub(256, shl(3, length))
    10472
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10473
                }
    10474
                m0 := mload(0x00)
    10475
                m1 := mload(0x20)
    10476
                m2 := mload(0x40)
    10477
                m3 := mload(0x60)
    10478
                m4 := mload(0x80)
    10479
                m5 := mload(0xa0)
    10480
                m6 := mload(0xc0)
    10481
                m7 := mload(0xe0)
    10482
                m8 := mload(0x100)
    10483
                // Selector of `log(uint256,string,uint256,string)`.
    10484
                mstore(0x00, 0xb7b914ca)
    10485
                mstore(0x20, p0)
    10486
                mstore(0x40, 0x80)
    10487
                mstore(0x60, p2)
    10488
                mstore(0x80, 0xc0)
    10489
                writeString(0xa0, p1)
    10490
                writeString(0xe0, p3)
    10491
            }
    10492
            _sendLogPayload(0x1c, 0x104);
    10493
            /// @solidity memory-safe-assembly
    10494
            assembly {
    10495
                mstore(0x00, m0)
    10496
                mstore(0x20, m1)
    10497
                mstore(0x40, m2)
    10498
                mstore(0x60, m3)
    10499
                mstore(0x80, m4)
    10500
                mstore(0xa0, m5)
    10501
                mstore(0xc0, m6)
    10502
                mstore(0xe0, m7)
    10503
                mstore(0x100, m8)
    10504
            }
    10505
        }
    10506
    
                                                    
                                                
    10507
        function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    10508
            bytes32 m0;
    10509
            bytes32 m1;
    10510
            bytes32 m2;
    10511
            bytes32 m3;
    10512
            bytes32 m4;
    10513
            bytes32 m5;
    10514
            bytes32 m6;
    10515
            bytes32 m7;
    10516
            bytes32 m8;
    10517
            /// @solidity memory-safe-assembly
    10518
            assembly {
    10519
                function writeString(pos, w) {
    10520
                    let length := 0
    10521
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10522
                    mstore(pos, length)
    10523
                    let shift := sub(256, shl(3, length))
    10524
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10525
                }
    10526
                m0 := mload(0x00)
    10527
                m1 := mload(0x20)
    10528
                m2 := mload(0x40)
    10529
                m3 := mload(0x60)
    10530
                m4 := mload(0x80)
    10531
                m5 := mload(0xa0)
    10532
                m6 := mload(0xc0)
    10533
                m7 := mload(0xe0)
    10534
                m8 := mload(0x100)
    10535
                // Selector of `log(uint256,string,string,address)`.
    10536
                mstore(0x00, 0xd583c602)
    10537
                mstore(0x20, p0)
    10538
                mstore(0x40, 0x80)
    10539
                mstore(0x60, 0xc0)
    10540
                mstore(0x80, p3)
    10541
                writeString(0xa0, p1)
    10542
                writeString(0xe0, p2)
    10543
            }
    10544
            _sendLogPayload(0x1c, 0x104);
    10545
            /// @solidity memory-safe-assembly
    10546
            assembly {
    10547
                mstore(0x00, m0)
    10548
                mstore(0x20, m1)
    10549
                mstore(0x40, m2)
    10550
                mstore(0x60, m3)
    10551
                mstore(0x80, m4)
    10552
                mstore(0xa0, m5)
    10553
                mstore(0xc0, m6)
    10554
                mstore(0xe0, m7)
    10555
                mstore(0x100, m8)
    10556
            }
    10557
        }
    10558
    
                                                    
                                                
    10559
        function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    10560
            bytes32 m0;
    10561
            bytes32 m1;
    10562
            bytes32 m2;
    10563
            bytes32 m3;
    10564
            bytes32 m4;
    10565
            bytes32 m5;
    10566
            bytes32 m6;
    10567
            bytes32 m7;
    10568
            bytes32 m8;
    10569
            /// @solidity memory-safe-assembly
    10570
            assembly {
    10571
                function writeString(pos, w) {
    10572
                    let length := 0
    10573
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10574
                    mstore(pos, length)
    10575
                    let shift := sub(256, shl(3, length))
    10576
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10577
                }
    10578
                m0 := mload(0x00)
    10579
                m1 := mload(0x20)
    10580
                m2 := mload(0x40)
    10581
                m3 := mload(0x60)
    10582
                m4 := mload(0x80)
    10583
                m5 := mload(0xa0)
    10584
                m6 := mload(0xc0)
    10585
                m7 := mload(0xe0)
    10586
                m8 := mload(0x100)
    10587
                // Selector of `log(uint256,string,string,bool)`.
    10588
                mstore(0x00, 0xb3a6b6bd)
    10589
                mstore(0x20, p0)
    10590
                mstore(0x40, 0x80)
    10591
                mstore(0x60, 0xc0)
    10592
                mstore(0x80, p3)
    10593
                writeString(0xa0, p1)
    10594
                writeString(0xe0, p2)
    10595
            }
    10596
            _sendLogPayload(0x1c, 0x104);
    10597
            /// @solidity memory-safe-assembly
    10598
            assembly {
    10599
                mstore(0x00, m0)
    10600
                mstore(0x20, m1)
    10601
                mstore(0x40, m2)
    10602
                mstore(0x60, m3)
    10603
                mstore(0x80, m4)
    10604
                mstore(0xa0, m5)
    10605
                mstore(0xc0, m6)
    10606
                mstore(0xe0, m7)
    10607
                mstore(0x100, m8)
    10608
            }
    10609
        }
    10610
    
                                                    
                                                
    10611
        function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    10612
            bytes32 m0;
    10613
            bytes32 m1;
    10614
            bytes32 m2;
    10615
            bytes32 m3;
    10616
            bytes32 m4;
    10617
            bytes32 m5;
    10618
            bytes32 m6;
    10619
            bytes32 m7;
    10620
            bytes32 m8;
    10621
            /// @solidity memory-safe-assembly
    10622
            assembly {
    10623
                function writeString(pos, w) {
    10624
                    let length := 0
    10625
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10626
                    mstore(pos, length)
    10627
                    let shift := sub(256, shl(3, length))
    10628
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10629
                }
    10630
                m0 := mload(0x00)
    10631
                m1 := mload(0x20)
    10632
                m2 := mload(0x40)
    10633
                m3 := mload(0x60)
    10634
                m4 := mload(0x80)
    10635
                m5 := mload(0xa0)
    10636
                m6 := mload(0xc0)
    10637
                m7 := mload(0xe0)
    10638
                m8 := mload(0x100)
    10639
                // Selector of `log(uint256,string,string,uint256)`.
    10640
                mstore(0x00, 0xb028c9bd)
    10641
                mstore(0x20, p0)
    10642
                mstore(0x40, 0x80)
    10643
                mstore(0x60, 0xc0)
    10644
                mstore(0x80, p3)
    10645
                writeString(0xa0, p1)
    10646
                writeString(0xe0, p2)
    10647
            }
    10648
            _sendLogPayload(0x1c, 0x104);
    10649
            /// @solidity memory-safe-assembly
    10650
            assembly {
    10651
                mstore(0x00, m0)
    10652
                mstore(0x20, m1)
    10653
                mstore(0x40, m2)
    10654
                mstore(0x60, m3)
    10655
                mstore(0x80, m4)
    10656
                mstore(0xa0, m5)
    10657
                mstore(0xc0, m6)
    10658
                mstore(0xe0, m7)
    10659
                mstore(0x100, m8)
    10660
            }
    10661
        }
    10662
    
                                                    
                                                
    10663
        function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    10664
            bytes32 m0;
    10665
            bytes32 m1;
    10666
            bytes32 m2;
    10667
            bytes32 m3;
    10668
            bytes32 m4;
    10669
            bytes32 m5;
    10670
            bytes32 m6;
    10671
            bytes32 m7;
    10672
            bytes32 m8;
    10673
            bytes32 m9;
    10674
            bytes32 m10;
    10675
            /// @solidity memory-safe-assembly
    10676
            assembly {
    10677
                function writeString(pos, w) {
    10678
                    let length := 0
    10679
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10680
                    mstore(pos, length)
    10681
                    let shift := sub(256, shl(3, length))
    10682
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10683
                }
    10684
                m0 := mload(0x00)
    10685
                m1 := mload(0x20)
    10686
                m2 := mload(0x40)
    10687
                m3 := mload(0x60)
    10688
                m4 := mload(0x80)
    10689
                m5 := mload(0xa0)
    10690
                m6 := mload(0xc0)
    10691
                m7 := mload(0xe0)
    10692
                m8 := mload(0x100)
    10693
                m9 := mload(0x120)
    10694
                m10 := mload(0x140)
    10695
                // Selector of `log(uint256,string,string,string)`.
    10696
                mstore(0x00, 0x21ad0683)
    10697
                mstore(0x20, p0)
    10698
                mstore(0x40, 0x80)
    10699
                mstore(0x60, 0xc0)
    10700
                mstore(0x80, 0x100)
    10701
                writeString(0xa0, p1)
    10702
                writeString(0xe0, p2)
    10703
                writeString(0x120, p3)
    10704
            }
    10705
            _sendLogPayload(0x1c, 0x144);
    10706
            /// @solidity memory-safe-assembly
    10707
            assembly {
    10708
                mstore(0x00, m0)
    10709
                mstore(0x20, m1)
    10710
                mstore(0x40, m2)
    10711
                mstore(0x60, m3)
    10712
                mstore(0x80, m4)
    10713
                mstore(0xa0, m5)
    10714
                mstore(0xc0, m6)
    10715
                mstore(0xe0, m7)
    10716
                mstore(0x100, m8)
    10717
                mstore(0x120, m9)
    10718
                mstore(0x140, m10)
    10719
            }
    10720
        }
    10721
    
                                                    
                                                
    10722
        function log(bytes32 p0, address p1, address p2, address p3) internal pure {
    10723
            bytes32 m0;
    10724
            bytes32 m1;
    10725
            bytes32 m2;
    10726
            bytes32 m3;
    10727
            bytes32 m4;
    10728
            bytes32 m5;
    10729
            bytes32 m6;
    10730
            /// @solidity memory-safe-assembly
    10731
            assembly {
    10732
                function writeString(pos, w) {
    10733
                    let length := 0
    10734
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10735
                    mstore(pos, length)
    10736
                    let shift := sub(256, shl(3, length))
    10737
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10738
                }
    10739
                m0 := mload(0x00)
    10740
                m1 := mload(0x20)
    10741
                m2 := mload(0x40)
    10742
                m3 := mload(0x60)
    10743
                m4 := mload(0x80)
    10744
                m5 := mload(0xa0)
    10745
                m6 := mload(0xc0)
    10746
                // Selector of `log(string,address,address,address)`.
    10747
                mstore(0x00, 0xed8f28f6)
    10748
                mstore(0x20, 0x80)
    10749
                mstore(0x40, p1)
    10750
                mstore(0x60, p2)
    10751
                mstore(0x80, p3)
    10752
                writeString(0xa0, p0)
    10753
            }
    10754
            _sendLogPayload(0x1c, 0xc4);
    10755
            /// @solidity memory-safe-assembly
    10756
            assembly {
    10757
                mstore(0x00, m0)
    10758
                mstore(0x20, m1)
    10759
                mstore(0x40, m2)
    10760
                mstore(0x60, m3)
    10761
                mstore(0x80, m4)
    10762
                mstore(0xa0, m5)
    10763
                mstore(0xc0, m6)
    10764
            }
    10765
        }
    10766
    
                                                    
                                                
    10767
        function log(bytes32 p0, address p1, address p2, bool p3) internal pure {
    10768
            bytes32 m0;
    10769
            bytes32 m1;
    10770
            bytes32 m2;
    10771
            bytes32 m3;
    10772
            bytes32 m4;
    10773
            bytes32 m5;
    10774
            bytes32 m6;
    10775
            /// @solidity memory-safe-assembly
    10776
            assembly {
    10777
                function writeString(pos, w) {
    10778
                    let length := 0
    10779
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10780
                    mstore(pos, length)
    10781
                    let shift := sub(256, shl(3, length))
    10782
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10783
                }
    10784
                m0 := mload(0x00)
    10785
                m1 := mload(0x20)
    10786
                m2 := mload(0x40)
    10787
                m3 := mload(0x60)
    10788
                m4 := mload(0x80)
    10789
                m5 := mload(0xa0)
    10790
                m6 := mload(0xc0)
    10791
                // Selector of `log(string,address,address,bool)`.
    10792
                mstore(0x00, 0xb59dbd60)
    10793
                mstore(0x20, 0x80)
    10794
                mstore(0x40, p1)
    10795
                mstore(0x60, p2)
    10796
                mstore(0x80, p3)
    10797
                writeString(0xa0, p0)
    10798
            }
    10799
            _sendLogPayload(0x1c, 0xc4);
    10800
            /// @solidity memory-safe-assembly
    10801
            assembly {
    10802
                mstore(0x00, m0)
    10803
                mstore(0x20, m1)
    10804
                mstore(0x40, m2)
    10805
                mstore(0x60, m3)
    10806
                mstore(0x80, m4)
    10807
                mstore(0xa0, m5)
    10808
                mstore(0xc0, m6)
    10809
            }
    10810
        }
    10811
    
                                                    
                                                
    10812
        function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {
    10813
            bytes32 m0;
    10814
            bytes32 m1;
    10815
            bytes32 m2;
    10816
            bytes32 m3;
    10817
            bytes32 m4;
    10818
            bytes32 m5;
    10819
            bytes32 m6;
    10820
            /// @solidity memory-safe-assembly
    10821
            assembly {
    10822
                function writeString(pos, w) {
    10823
                    let length := 0
    10824
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10825
                    mstore(pos, length)
    10826
                    let shift := sub(256, shl(3, length))
    10827
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10828
                }
    10829
                m0 := mload(0x00)
    10830
                m1 := mload(0x20)
    10831
                m2 := mload(0x40)
    10832
                m3 := mload(0x60)
    10833
                m4 := mload(0x80)
    10834
                m5 := mload(0xa0)
    10835
                m6 := mload(0xc0)
    10836
                // Selector of `log(string,address,address,uint256)`.
    10837
                mstore(0x00, 0x8ef3f399)
    10838
                mstore(0x20, 0x80)
    10839
                mstore(0x40, p1)
    10840
                mstore(0x60, p2)
    10841
                mstore(0x80, p3)
    10842
                writeString(0xa0, p0)
    10843
            }
    10844
            _sendLogPayload(0x1c, 0xc4);
    10845
            /// @solidity memory-safe-assembly
    10846
            assembly {
    10847
                mstore(0x00, m0)
    10848
                mstore(0x20, m1)
    10849
                mstore(0x40, m2)
    10850
                mstore(0x60, m3)
    10851
                mstore(0x80, m4)
    10852
                mstore(0xa0, m5)
    10853
                mstore(0xc0, m6)
    10854
            }
    10855
        }
    10856
    
                                                    
                                                
    10857
        function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {
    10858
            bytes32 m0;
    10859
            bytes32 m1;
    10860
            bytes32 m2;
    10861
            bytes32 m3;
    10862
            bytes32 m4;
    10863
            bytes32 m5;
    10864
            bytes32 m6;
    10865
            bytes32 m7;
    10866
            bytes32 m8;
    10867
            /// @solidity memory-safe-assembly
    10868
            assembly {
    10869
                function writeString(pos, w) {
    10870
                    let length := 0
    10871
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10872
                    mstore(pos, length)
    10873
                    let shift := sub(256, shl(3, length))
    10874
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10875
                }
    10876
                m0 := mload(0x00)
    10877
                m1 := mload(0x20)
    10878
                m2 := mload(0x40)
    10879
                m3 := mload(0x60)
    10880
                m4 := mload(0x80)
    10881
                m5 := mload(0xa0)
    10882
                m6 := mload(0xc0)
    10883
                m7 := mload(0xe0)
    10884
                m8 := mload(0x100)
    10885
                // Selector of `log(string,address,address,string)`.
    10886
                mstore(0x00, 0x800a1c67)
    10887
                mstore(0x20, 0x80)
    10888
                mstore(0x40, p1)
    10889
                mstore(0x60, p2)
    10890
                mstore(0x80, 0xc0)
    10891
                writeString(0xa0, p0)
    10892
                writeString(0xe0, p3)
    10893
            }
    10894
            _sendLogPayload(0x1c, 0x104);
    10895
            /// @solidity memory-safe-assembly
    10896
            assembly {
    10897
                mstore(0x00, m0)
    10898
                mstore(0x20, m1)
    10899
                mstore(0x40, m2)
    10900
                mstore(0x60, m3)
    10901
                mstore(0x80, m4)
    10902
                mstore(0xa0, m5)
    10903
                mstore(0xc0, m6)
    10904
                mstore(0xe0, m7)
    10905
                mstore(0x100, m8)
    10906
            }
    10907
        }
    10908
    
                                                    
                                                
    10909
        function log(bytes32 p0, address p1, bool p2, address p3) internal pure {
    10910
            bytes32 m0;
    10911
            bytes32 m1;
    10912
            bytes32 m2;
    10913
            bytes32 m3;
    10914
            bytes32 m4;
    10915
            bytes32 m5;
    10916
            bytes32 m6;
    10917
            /// @solidity memory-safe-assembly
    10918
            assembly {
    10919
                function writeString(pos, w) {
    10920
                    let length := 0
    10921
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10922
                    mstore(pos, length)
    10923
                    let shift := sub(256, shl(3, length))
    10924
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10925
                }
    10926
                m0 := mload(0x00)
    10927
                m1 := mload(0x20)
    10928
                m2 := mload(0x40)
    10929
                m3 := mload(0x60)
    10930
                m4 := mload(0x80)
    10931
                m5 := mload(0xa0)
    10932
                m6 := mload(0xc0)
    10933
                // Selector of `log(string,address,bool,address)`.
    10934
                mstore(0x00, 0x223603bd)
    10935
                mstore(0x20, 0x80)
    10936
                mstore(0x40, p1)
    10937
                mstore(0x60, p2)
    10938
                mstore(0x80, p3)
    10939
                writeString(0xa0, p0)
    10940
            }
    10941
            _sendLogPayload(0x1c, 0xc4);
    10942
            /// @solidity memory-safe-assembly
    10943
            assembly {
    10944
                mstore(0x00, m0)
    10945
                mstore(0x20, m1)
    10946
                mstore(0x40, m2)
    10947
                mstore(0x60, m3)
    10948
                mstore(0x80, m4)
    10949
                mstore(0xa0, m5)
    10950
                mstore(0xc0, m6)
    10951
            }
    10952
        }
    10953
    
                                                    
                                                
    10954
        function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {
    10955
            bytes32 m0;
    10956
            bytes32 m1;
    10957
            bytes32 m2;
    10958
            bytes32 m3;
    10959
            bytes32 m4;
    10960
            bytes32 m5;
    10961
            bytes32 m6;
    10962
            /// @solidity memory-safe-assembly
    10963
            assembly {
    10964
                function writeString(pos, w) {
    10965
                    let length := 0
    10966
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10967
                    mstore(pos, length)
    10968
                    let shift := sub(256, shl(3, length))
    10969
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10970
                }
    10971
                m0 := mload(0x00)
    10972
                m1 := mload(0x20)
    10973
                m2 := mload(0x40)
    10974
                m3 := mload(0x60)
    10975
                m4 := mload(0x80)
    10976
                m5 := mload(0xa0)
    10977
                m6 := mload(0xc0)
    10978
                // Selector of `log(string,address,bool,bool)`.
    10979
                mstore(0x00, 0x79884c2b)
    10980
                mstore(0x20, 0x80)
    10981
                mstore(0x40, p1)
    10982
                mstore(0x60, p2)
    10983
                mstore(0x80, p3)
    10984
                writeString(0xa0, p0)
    10985
            }
    10986
            _sendLogPayload(0x1c, 0xc4);
    10987
            /// @solidity memory-safe-assembly
    10988
            assembly {
    10989
                mstore(0x00, m0)
    10990
                mstore(0x20, m1)
    10991
                mstore(0x40, m2)
    10992
                mstore(0x60, m3)
    10993
                mstore(0x80, m4)
    10994
                mstore(0xa0, m5)
    10995
                mstore(0xc0, m6)
    10996
            }
    10997
        }
    10998
    
                                                    
                                                
    10999
        function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {
    11000
            bytes32 m0;
    11001
            bytes32 m1;
    11002
            bytes32 m2;
    11003
            bytes32 m3;
    11004
            bytes32 m4;
    11005
            bytes32 m5;
    11006
            bytes32 m6;
    11007
            /// @solidity memory-safe-assembly
    11008
            assembly {
    11009
                function writeString(pos, w) {
    11010
                    let length := 0
    11011
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11012
                    mstore(pos, length)
    11013
                    let shift := sub(256, shl(3, length))
    11014
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11015
                }
    11016
                m0 := mload(0x00)
    11017
                m1 := mload(0x20)
    11018
                m2 := mload(0x40)
    11019
                m3 := mload(0x60)
    11020
                m4 := mload(0x80)
    11021
                m5 := mload(0xa0)
    11022
                m6 := mload(0xc0)
    11023
                // Selector of `log(string,address,bool,uint256)`.
    11024
                mstore(0x00, 0x3e9f866a)
    11025
                mstore(0x20, 0x80)
    11026
                mstore(0x40, p1)
    11027
                mstore(0x60, p2)
    11028
                mstore(0x80, p3)
    11029
                writeString(0xa0, p0)
    11030
            }
    11031
            _sendLogPayload(0x1c, 0xc4);
    11032
            /// @solidity memory-safe-assembly
    11033
            assembly {
    11034
                mstore(0x00, m0)
    11035
                mstore(0x20, m1)
    11036
                mstore(0x40, m2)
    11037
                mstore(0x60, m3)
    11038
                mstore(0x80, m4)
    11039
                mstore(0xa0, m5)
    11040
                mstore(0xc0, m6)
    11041
            }
    11042
        }
    11043
    
                                                    
                                                
    11044
        function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {
    11045
            bytes32 m0;
    11046
            bytes32 m1;
    11047
            bytes32 m2;
    11048
            bytes32 m3;
    11049
            bytes32 m4;
    11050
            bytes32 m5;
    11051
            bytes32 m6;
    11052
            bytes32 m7;
    11053
            bytes32 m8;
    11054
            /// @solidity memory-safe-assembly
    11055
            assembly {
    11056
                function writeString(pos, w) {
    11057
                    let length := 0
    11058
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11059
                    mstore(pos, length)
    11060
                    let shift := sub(256, shl(3, length))
    11061
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11062
                }
    11063
                m0 := mload(0x00)
    11064
                m1 := mload(0x20)
    11065
                m2 := mload(0x40)
    11066
                m3 := mload(0x60)
    11067
                m4 := mload(0x80)
    11068
                m5 := mload(0xa0)
    11069
                m6 := mload(0xc0)
    11070
                m7 := mload(0xe0)
    11071
                m8 := mload(0x100)
    11072
                // Selector of `log(string,address,bool,string)`.
    11073
                mstore(0x00, 0x0454c079)
    11074
                mstore(0x20, 0x80)
    11075
                mstore(0x40, p1)
    11076
                mstore(0x60, p2)
    11077
                mstore(0x80, 0xc0)
    11078
                writeString(0xa0, p0)
    11079
                writeString(0xe0, p3)
    11080
            }
    11081
            _sendLogPayload(0x1c, 0x104);
    11082
            /// @solidity memory-safe-assembly
    11083
            assembly {
    11084
                mstore(0x00, m0)
    11085
                mstore(0x20, m1)
    11086
                mstore(0x40, m2)
    11087
                mstore(0x60, m3)
    11088
                mstore(0x80, m4)
    11089
                mstore(0xa0, m5)
    11090
                mstore(0xc0, m6)
    11091
                mstore(0xe0, m7)
    11092
                mstore(0x100, m8)
    11093
            }
    11094
        }
    11095
    
                                                    
                                                
    11096
        function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {
    11097
            bytes32 m0;
    11098
            bytes32 m1;
    11099
            bytes32 m2;
    11100
            bytes32 m3;
    11101
            bytes32 m4;
    11102
            bytes32 m5;
    11103
            bytes32 m6;
    11104
            /// @solidity memory-safe-assembly
    11105
            assembly {
    11106
                function writeString(pos, w) {
    11107
                    let length := 0
    11108
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11109
                    mstore(pos, length)
    11110
                    let shift := sub(256, shl(3, length))
    11111
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11112
                }
    11113
                m0 := mload(0x00)
    11114
                m1 := mload(0x20)
    11115
                m2 := mload(0x40)
    11116
                m3 := mload(0x60)
    11117
                m4 := mload(0x80)
    11118
                m5 := mload(0xa0)
    11119
                m6 := mload(0xc0)
    11120
                // Selector of `log(string,address,uint256,address)`.
    11121
                mstore(0x00, 0x63fb8bc5)
    11122
                mstore(0x20, 0x80)
    11123
                mstore(0x40, p1)
    11124
                mstore(0x60, p2)
    11125
                mstore(0x80, p3)
    11126
                writeString(0xa0, p0)
    11127
            }
    11128
            _sendLogPayload(0x1c, 0xc4);
    11129
            /// @solidity memory-safe-assembly
    11130
            assembly {
    11131
                mstore(0x00, m0)
    11132
                mstore(0x20, m1)
    11133
                mstore(0x40, m2)
    11134
                mstore(0x60, m3)
    11135
                mstore(0x80, m4)
    11136
                mstore(0xa0, m5)
    11137
                mstore(0xc0, m6)
    11138
            }
    11139
        }
    11140
    
                                                    
                                                
    11141
        function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {
    11142
            bytes32 m0;
    11143
            bytes32 m1;
    11144
            bytes32 m2;
    11145
            bytes32 m3;
    11146
            bytes32 m4;
    11147
            bytes32 m5;
    11148
            bytes32 m6;
    11149
            /// @solidity memory-safe-assembly
    11150
            assembly {
    11151
                function writeString(pos, w) {
    11152
                    let length := 0
    11153
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11154
                    mstore(pos, length)
    11155
                    let shift := sub(256, shl(3, length))
    11156
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11157
                }
    11158
                m0 := mload(0x00)
    11159
                m1 := mload(0x20)
    11160
                m2 := mload(0x40)
    11161
                m3 := mload(0x60)
    11162
                m4 := mload(0x80)
    11163
                m5 := mload(0xa0)
    11164
                m6 := mload(0xc0)
    11165
                // Selector of `log(string,address,uint256,bool)`.
    11166
                mstore(0x00, 0xfc4845f0)
    11167
                mstore(0x20, 0x80)
    11168
                mstore(0x40, p1)
    11169
                mstore(0x60, p2)
    11170
                mstore(0x80, p3)
    11171
                writeString(0xa0, p0)
    11172
            }
    11173
            _sendLogPayload(0x1c, 0xc4);
    11174
            /// @solidity memory-safe-assembly
    11175
            assembly {
    11176
                mstore(0x00, m0)
    11177
                mstore(0x20, m1)
    11178
                mstore(0x40, m2)
    11179
                mstore(0x60, m3)
    11180
                mstore(0x80, m4)
    11181
                mstore(0xa0, m5)
    11182
                mstore(0xc0, m6)
    11183
            }
    11184
        }
    11185
    
                                                    
                                                
    11186
        function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {
    11187
            bytes32 m0;
    11188
            bytes32 m1;
    11189
            bytes32 m2;
    11190
            bytes32 m3;
    11191
            bytes32 m4;
    11192
            bytes32 m5;
    11193
            bytes32 m6;
    11194
            /// @solidity memory-safe-assembly
    11195
            assembly {
    11196
                function writeString(pos, w) {
    11197
                    let length := 0
    11198
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11199
                    mstore(pos, length)
    11200
                    let shift := sub(256, shl(3, length))
    11201
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11202
                }
    11203
                m0 := mload(0x00)
    11204
                m1 := mload(0x20)
    11205
                m2 := mload(0x40)
    11206
                m3 := mload(0x60)
    11207
                m4 := mload(0x80)
    11208
                m5 := mload(0xa0)
    11209
                m6 := mload(0xc0)
    11210
                // Selector of `log(string,address,uint256,uint256)`.
    11211
                mstore(0x00, 0xf8f51b1e)
    11212
                mstore(0x20, 0x80)
    11213
                mstore(0x40, p1)
    11214
                mstore(0x60, p2)
    11215
                mstore(0x80, p3)
    11216
                writeString(0xa0, p0)
    11217
            }
    11218
            _sendLogPayload(0x1c, 0xc4);
    11219
            /// @solidity memory-safe-assembly
    11220
            assembly {
    11221
                mstore(0x00, m0)
    11222
                mstore(0x20, m1)
    11223
                mstore(0x40, m2)
    11224
                mstore(0x60, m3)
    11225
                mstore(0x80, m4)
    11226
                mstore(0xa0, m5)
    11227
                mstore(0xc0, m6)
    11228
            }
    11229
        }
    11230
    
                                                    
                                                
    11231
        function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {
    11232
            bytes32 m0;
    11233
            bytes32 m1;
    11234
            bytes32 m2;
    11235
            bytes32 m3;
    11236
            bytes32 m4;
    11237
            bytes32 m5;
    11238
            bytes32 m6;
    11239
            bytes32 m7;
    11240
            bytes32 m8;
    11241
            /// @solidity memory-safe-assembly
    11242
            assembly {
    11243
                function writeString(pos, w) {
    11244
                    let length := 0
    11245
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11246
                    mstore(pos, length)
    11247
                    let shift := sub(256, shl(3, length))
    11248
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11249
                }
    11250
                m0 := mload(0x00)
    11251
                m1 := mload(0x20)
    11252
                m2 := mload(0x40)
    11253
                m3 := mload(0x60)
    11254
                m4 := mload(0x80)
    11255
                m5 := mload(0xa0)
    11256
                m6 := mload(0xc0)
    11257
                m7 := mload(0xe0)
    11258
                m8 := mload(0x100)
    11259
                // Selector of `log(string,address,uint256,string)`.
    11260
                mstore(0x00, 0x5a477632)
    11261
                mstore(0x20, 0x80)
    11262
                mstore(0x40, p1)
    11263
                mstore(0x60, p2)
    11264
                mstore(0x80, 0xc0)
    11265
                writeString(0xa0, p0)
    11266
                writeString(0xe0, p3)
    11267
            }
    11268
            _sendLogPayload(0x1c, 0x104);
    11269
            /// @solidity memory-safe-assembly
    11270
            assembly {
    11271
                mstore(0x00, m0)
    11272
                mstore(0x20, m1)
    11273
                mstore(0x40, m2)
    11274
                mstore(0x60, m3)
    11275
                mstore(0x80, m4)
    11276
                mstore(0xa0, m5)
    11277
                mstore(0xc0, m6)
    11278
                mstore(0xe0, m7)
    11279
                mstore(0x100, m8)
    11280
            }
    11281
        }
    11282
    
                                                    
                                                
    11283
        function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {
    11284
            bytes32 m0;
    11285
            bytes32 m1;
    11286
            bytes32 m2;
    11287
            bytes32 m3;
    11288
            bytes32 m4;
    11289
            bytes32 m5;
    11290
            bytes32 m6;
    11291
            bytes32 m7;
    11292
            bytes32 m8;
    11293
            /// @solidity memory-safe-assembly
    11294
            assembly {
    11295
                function writeString(pos, w) {
    11296
                    let length := 0
    11297
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11298
                    mstore(pos, length)
    11299
                    let shift := sub(256, shl(3, length))
    11300
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11301
                }
    11302
                m0 := mload(0x00)
    11303
                m1 := mload(0x20)
    11304
                m2 := mload(0x40)
    11305
                m3 := mload(0x60)
    11306
                m4 := mload(0x80)
    11307
                m5 := mload(0xa0)
    11308
                m6 := mload(0xc0)
    11309
                m7 := mload(0xe0)
    11310
                m8 := mload(0x100)
    11311
                // Selector of `log(string,address,string,address)`.
    11312
                mstore(0x00, 0xaabc9a31)
    11313
                mstore(0x20, 0x80)
    11314
                mstore(0x40, p1)
    11315
                mstore(0x60, 0xc0)
    11316
                mstore(0x80, p3)
    11317
                writeString(0xa0, p0)
    11318
                writeString(0xe0, p2)
    11319
            }
    11320
            _sendLogPayload(0x1c, 0x104);
    11321
            /// @solidity memory-safe-assembly
    11322
            assembly {
    11323
                mstore(0x00, m0)
    11324
                mstore(0x20, m1)
    11325
                mstore(0x40, m2)
    11326
                mstore(0x60, m3)
    11327
                mstore(0x80, m4)
    11328
                mstore(0xa0, m5)
    11329
                mstore(0xc0, m6)
    11330
                mstore(0xe0, m7)
    11331
                mstore(0x100, m8)
    11332
            }
    11333
        }
    11334
    
                                                    
                                                
    11335
        function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {
    11336
            bytes32 m0;
    11337
            bytes32 m1;
    11338
            bytes32 m2;
    11339
            bytes32 m3;
    11340
            bytes32 m4;
    11341
            bytes32 m5;
    11342
            bytes32 m6;
    11343
            bytes32 m7;
    11344
            bytes32 m8;
    11345
            /// @solidity memory-safe-assembly
    11346
            assembly {
    11347
                function writeString(pos, w) {
    11348
                    let length := 0
    11349
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11350
                    mstore(pos, length)
    11351
                    let shift := sub(256, shl(3, length))
    11352
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11353
                }
    11354
                m0 := mload(0x00)
    11355
                m1 := mload(0x20)
    11356
                m2 := mload(0x40)
    11357
                m3 := mload(0x60)
    11358
                m4 := mload(0x80)
    11359
                m5 := mload(0xa0)
    11360
                m6 := mload(0xc0)
    11361
                m7 := mload(0xe0)
    11362
                m8 := mload(0x100)
    11363
                // Selector of `log(string,address,string,bool)`.
    11364
                mstore(0x00, 0x5f15d28c)
    11365
                mstore(0x20, 0x80)
    11366
                mstore(0x40, p1)
    11367
                mstore(0x60, 0xc0)
    11368
                mstore(0x80, p3)
    11369
                writeString(0xa0, p0)
    11370
                writeString(0xe0, p2)
    11371
            }
    11372
            _sendLogPayload(0x1c, 0x104);
    11373
            /// @solidity memory-safe-assembly
    11374
            assembly {
    11375
                mstore(0x00, m0)
    11376
                mstore(0x20, m1)
    11377
                mstore(0x40, m2)
    11378
                mstore(0x60, m3)
    11379
                mstore(0x80, m4)
    11380
                mstore(0xa0, m5)
    11381
                mstore(0xc0, m6)
    11382
                mstore(0xe0, m7)
    11383
                mstore(0x100, m8)
    11384
            }
    11385
        }
    11386
    
                                                    
                                                
    11387
        function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {
    11388
            bytes32 m0;
    11389
            bytes32 m1;
    11390
            bytes32 m2;
    11391
            bytes32 m3;
    11392
            bytes32 m4;
    11393
            bytes32 m5;
    11394
            bytes32 m6;
    11395
            bytes32 m7;
    11396
            bytes32 m8;
    11397
            /// @solidity memory-safe-assembly
    11398
            assembly {
    11399
                function writeString(pos, w) {
    11400
                    let length := 0
    11401
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11402
                    mstore(pos, length)
    11403
                    let shift := sub(256, shl(3, length))
    11404
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11405
                }
    11406
                m0 := mload(0x00)
    11407
                m1 := mload(0x20)
    11408
                m2 := mload(0x40)
    11409
                m3 := mload(0x60)
    11410
                m4 := mload(0x80)
    11411
                m5 := mload(0xa0)
    11412
                m6 := mload(0xc0)
    11413
                m7 := mload(0xe0)
    11414
                m8 := mload(0x100)
    11415
                // Selector of `log(string,address,string,uint256)`.
    11416
                mstore(0x00, 0x91d1112e)
    11417
                mstore(0x20, 0x80)
    11418
                mstore(0x40, p1)
    11419
                mstore(0x60, 0xc0)
    11420
                mstore(0x80, p3)
    11421
                writeString(0xa0, p0)
    11422
                writeString(0xe0, p2)
    11423
            }
    11424
            _sendLogPayload(0x1c, 0x104);
    11425
            /// @solidity memory-safe-assembly
    11426
            assembly {
    11427
                mstore(0x00, m0)
    11428
                mstore(0x20, m1)
    11429
                mstore(0x40, m2)
    11430
                mstore(0x60, m3)
    11431
                mstore(0x80, m4)
    11432
                mstore(0xa0, m5)
    11433
                mstore(0xc0, m6)
    11434
                mstore(0xe0, m7)
    11435
                mstore(0x100, m8)
    11436
            }
    11437
        }
    11438
    
                                                    
                                                
    11439
        function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    11440
            bytes32 m0;
    11441
            bytes32 m1;
    11442
            bytes32 m2;
    11443
            bytes32 m3;
    11444
            bytes32 m4;
    11445
            bytes32 m5;
    11446
            bytes32 m6;
    11447
            bytes32 m7;
    11448
            bytes32 m8;
    11449
            bytes32 m9;
    11450
            bytes32 m10;
    11451
            /// @solidity memory-safe-assembly
    11452
            assembly {
    11453
                function writeString(pos, w) {
    11454
                    let length := 0
    11455
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11456
                    mstore(pos, length)
    11457
                    let shift := sub(256, shl(3, length))
    11458
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11459
                }
    11460
                m0 := mload(0x00)
    11461
                m1 := mload(0x20)
    11462
                m2 := mload(0x40)
    11463
                m3 := mload(0x60)
    11464
                m4 := mload(0x80)
    11465
                m5 := mload(0xa0)
    11466
                m6 := mload(0xc0)
    11467
                m7 := mload(0xe0)
    11468
                m8 := mload(0x100)
    11469
                m9 := mload(0x120)
    11470
                m10 := mload(0x140)
    11471
                // Selector of `log(string,address,string,string)`.
    11472
                mstore(0x00, 0x245986f2)
    11473
                mstore(0x20, 0x80)
    11474
                mstore(0x40, p1)
    11475
                mstore(0x60, 0xc0)
    11476
                mstore(0x80, 0x100)
    11477
                writeString(0xa0, p0)
    11478
                writeString(0xe0, p2)
    11479
                writeString(0x120, p3)
    11480
            }
    11481
            _sendLogPayload(0x1c, 0x144);
    11482
            /// @solidity memory-safe-assembly
    11483
            assembly {
    11484
                mstore(0x00, m0)
    11485
                mstore(0x20, m1)
    11486
                mstore(0x40, m2)
    11487
                mstore(0x60, m3)
    11488
                mstore(0x80, m4)
    11489
                mstore(0xa0, m5)
    11490
                mstore(0xc0, m6)
    11491
                mstore(0xe0, m7)
    11492
                mstore(0x100, m8)
    11493
                mstore(0x120, m9)
    11494
                mstore(0x140, m10)
    11495
            }
    11496
        }
    11497
    
                                                    
                                                
    11498
        function log(bytes32 p0, bool p1, address p2, address p3) internal pure {
    11499
            bytes32 m0;
    11500
            bytes32 m1;
    11501
            bytes32 m2;
    11502
            bytes32 m3;
    11503
            bytes32 m4;
    11504
            bytes32 m5;
    11505
            bytes32 m6;
    11506
            /// @solidity memory-safe-assembly
    11507
            assembly {
    11508
                function writeString(pos, w) {
    11509
                    let length := 0
    11510
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11511
                    mstore(pos, length)
    11512
                    let shift := sub(256, shl(3, length))
    11513
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11514
                }
    11515
                m0 := mload(0x00)
    11516
                m1 := mload(0x20)
    11517
                m2 := mload(0x40)
    11518
                m3 := mload(0x60)
    11519
                m4 := mload(0x80)
    11520
                m5 := mload(0xa0)
    11521
                m6 := mload(0xc0)
    11522
                // Selector of `log(string,bool,address,address)`.
    11523
                mstore(0x00, 0x33e9dd1d)
    11524
                mstore(0x20, 0x80)
    11525
                mstore(0x40, p1)
    11526
                mstore(0x60, p2)
    11527
                mstore(0x80, p3)
    11528
                writeString(0xa0, p0)
    11529
            }
    11530
            _sendLogPayload(0x1c, 0xc4);
    11531
            /// @solidity memory-safe-assembly
    11532
            assembly {
    11533
                mstore(0x00, m0)
    11534
                mstore(0x20, m1)
    11535
                mstore(0x40, m2)
    11536
                mstore(0x60, m3)
    11537
                mstore(0x80, m4)
    11538
                mstore(0xa0, m5)
    11539
                mstore(0xc0, m6)
    11540
            }
    11541
        }
    11542
    
                                                    
                                                
    11543
        function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {
    11544
            bytes32 m0;
    11545
            bytes32 m1;
    11546
            bytes32 m2;
    11547
            bytes32 m3;
    11548
            bytes32 m4;
    11549
            bytes32 m5;
    11550
            bytes32 m6;
    11551
            /// @solidity memory-safe-assembly
    11552
            assembly {
    11553
                function writeString(pos, w) {
    11554
                    let length := 0
    11555
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11556
                    mstore(pos, length)
    11557
                    let shift := sub(256, shl(3, length))
    11558
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11559
                }
    11560
                m0 := mload(0x00)
    11561
                m1 := mload(0x20)
    11562
                m2 := mload(0x40)
    11563
                m3 := mload(0x60)
    11564
                m4 := mload(0x80)
    11565
                m5 := mload(0xa0)
    11566
                m6 := mload(0xc0)
    11567
                // Selector of `log(string,bool,address,bool)`.
    11568
                mstore(0x00, 0x958c28c6)
    11569
                mstore(0x20, 0x80)
    11570
                mstore(0x40, p1)
    11571
                mstore(0x60, p2)
    11572
                mstore(0x80, p3)
    11573
                writeString(0xa0, p0)
    11574
            }
    11575
            _sendLogPayload(0x1c, 0xc4);
    11576
            /// @solidity memory-safe-assembly
    11577
            assembly {
    11578
                mstore(0x00, m0)
    11579
                mstore(0x20, m1)
    11580
                mstore(0x40, m2)
    11581
                mstore(0x60, m3)
    11582
                mstore(0x80, m4)
    11583
                mstore(0xa0, m5)
    11584
                mstore(0xc0, m6)
    11585
            }
    11586
        }
    11587
    
                                                    
                                                
    11588
        function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {
    11589
            bytes32 m0;
    11590
            bytes32 m1;
    11591
            bytes32 m2;
    11592
            bytes32 m3;
    11593
            bytes32 m4;
    11594
            bytes32 m5;
    11595
            bytes32 m6;
    11596
            /// @solidity memory-safe-assembly
    11597
            assembly {
    11598
                function writeString(pos, w) {
    11599
                    let length := 0
    11600
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11601
                    mstore(pos, length)
    11602
                    let shift := sub(256, shl(3, length))
    11603
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11604
                }
    11605
                m0 := mload(0x00)
    11606
                m1 := mload(0x20)
    11607
                m2 := mload(0x40)
    11608
                m3 := mload(0x60)
    11609
                m4 := mload(0x80)
    11610
                m5 := mload(0xa0)
    11611
                m6 := mload(0xc0)
    11612
                // Selector of `log(string,bool,address,uint256)`.
    11613
                mstore(0x00, 0x5d08bb05)
    11614
                mstore(0x20, 0x80)
    11615
                mstore(0x40, p1)
    11616
                mstore(0x60, p2)
    11617
                mstore(0x80, p3)
    11618
                writeString(0xa0, p0)
    11619
            }
    11620
            _sendLogPayload(0x1c, 0xc4);
    11621
            /// @solidity memory-safe-assembly
    11622
            assembly {
    11623
                mstore(0x00, m0)
    11624
                mstore(0x20, m1)
    11625
                mstore(0x40, m2)
    11626
                mstore(0x60, m3)
    11627
                mstore(0x80, m4)
    11628
                mstore(0xa0, m5)
    11629
                mstore(0xc0, m6)
    11630
            }
    11631
        }
    11632
    
                                                    
                                                
    11633
        function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {
    11634
            bytes32 m0;
    11635
            bytes32 m1;
    11636
            bytes32 m2;
    11637
            bytes32 m3;
    11638
            bytes32 m4;
    11639
            bytes32 m5;
    11640
            bytes32 m6;
    11641
            bytes32 m7;
    11642
            bytes32 m8;
    11643
            /// @solidity memory-safe-assembly
    11644
            assembly {
    11645
                function writeString(pos, w) {
    11646
                    let length := 0
    11647
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11648
                    mstore(pos, length)
    11649
                    let shift := sub(256, shl(3, length))
    11650
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11651
                }
    11652
                m0 := mload(0x00)
    11653
                m1 := mload(0x20)
    11654
                m2 := mload(0x40)
    11655
                m3 := mload(0x60)
    11656
                m4 := mload(0x80)
    11657
                m5 := mload(0xa0)
    11658
                m6 := mload(0xc0)
    11659
                m7 := mload(0xe0)
    11660
                m8 := mload(0x100)
    11661
                // Selector of `log(string,bool,address,string)`.
    11662
                mstore(0x00, 0x2d8e33a4)
    11663
                mstore(0x20, 0x80)
    11664
                mstore(0x40, p1)
    11665
                mstore(0x60, p2)
    11666
                mstore(0x80, 0xc0)
    11667
                writeString(0xa0, p0)
    11668
                writeString(0xe0, p3)
    11669
            }
    11670
            _sendLogPayload(0x1c, 0x104);
    11671
            /// @solidity memory-safe-assembly
    11672
            assembly {
    11673
                mstore(0x00, m0)
    11674
                mstore(0x20, m1)
    11675
                mstore(0x40, m2)
    11676
                mstore(0x60, m3)
    11677
                mstore(0x80, m4)
    11678
                mstore(0xa0, m5)
    11679
                mstore(0xc0, m6)
    11680
                mstore(0xe0, m7)
    11681
                mstore(0x100, m8)
    11682
            }
    11683
        }
    11684
    
                                                    
                                                
    11685
        function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {
    11686
            bytes32 m0;
    11687
            bytes32 m1;
    11688
            bytes32 m2;
    11689
            bytes32 m3;
    11690
            bytes32 m4;
    11691
            bytes32 m5;
    11692
            bytes32 m6;
    11693
            /// @solidity memory-safe-assembly
    11694
            assembly {
    11695
                function writeString(pos, w) {
    11696
                    let length := 0
    11697
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11698
                    mstore(pos, length)
    11699
                    let shift := sub(256, shl(3, length))
    11700
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11701
                }
    11702
                m0 := mload(0x00)
    11703
                m1 := mload(0x20)
    11704
                m2 := mload(0x40)
    11705
                m3 := mload(0x60)
    11706
                m4 := mload(0x80)
    11707
                m5 := mload(0xa0)
    11708
                m6 := mload(0xc0)
    11709
                // Selector of `log(string,bool,bool,address)`.
    11710
                mstore(0x00, 0x7190a529)
    11711
                mstore(0x20, 0x80)
    11712
                mstore(0x40, p1)
    11713
                mstore(0x60, p2)
    11714
                mstore(0x80, p3)
    11715
                writeString(0xa0, p0)
    11716
            }
    11717
            _sendLogPayload(0x1c, 0xc4);
    11718
            /// @solidity memory-safe-assembly
    11719
            assembly {
    11720
                mstore(0x00, m0)
    11721
                mstore(0x20, m1)
    11722
                mstore(0x40, m2)
    11723
                mstore(0x60, m3)
    11724
                mstore(0x80, m4)
    11725
                mstore(0xa0, m5)
    11726
                mstore(0xc0, m6)
    11727
            }
    11728
        }
    11729
    
                                                    
                                                
    11730
        function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {
    11731
            bytes32 m0;
    11732
            bytes32 m1;
    11733
            bytes32 m2;
    11734
            bytes32 m3;
    11735
            bytes32 m4;
    11736
            bytes32 m5;
    11737
            bytes32 m6;
    11738
            /// @solidity memory-safe-assembly
    11739
            assembly {
    11740
                function writeString(pos, w) {
    11741
                    let length := 0
    11742
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11743
                    mstore(pos, length)
    11744
                    let shift := sub(256, shl(3, length))
    11745
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11746
                }
    11747
                m0 := mload(0x00)
    11748
                m1 := mload(0x20)
    11749
                m2 := mload(0x40)
    11750
                m3 := mload(0x60)
    11751
                m4 := mload(0x80)
    11752
                m5 := mload(0xa0)
    11753
                m6 := mload(0xc0)
    11754
                // Selector of `log(string,bool,bool,bool)`.
    11755
                mstore(0x00, 0x895af8c5)
    11756
                mstore(0x20, 0x80)
    11757
                mstore(0x40, p1)
    11758
                mstore(0x60, p2)
    11759
                mstore(0x80, p3)
    11760
                writeString(0xa0, p0)
    11761
            }
    11762
            _sendLogPayload(0x1c, 0xc4);
    11763
            /// @solidity memory-safe-assembly
    11764
            assembly {
    11765
                mstore(0x00, m0)
    11766
                mstore(0x20, m1)
    11767
                mstore(0x40, m2)
    11768
                mstore(0x60, m3)
    11769
                mstore(0x80, m4)
    11770
                mstore(0xa0, m5)
    11771
                mstore(0xc0, m6)
    11772
            }
    11773
        }
    11774
    
                                                    
                                                
    11775
        function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {
    11776
            bytes32 m0;
    11777
            bytes32 m1;
    11778
            bytes32 m2;
    11779
            bytes32 m3;
    11780
            bytes32 m4;
    11781
            bytes32 m5;
    11782
            bytes32 m6;
    11783
            /// @solidity memory-safe-assembly
    11784
            assembly {
    11785
                function writeString(pos, w) {
    11786
                    let length := 0
    11787
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11788
                    mstore(pos, length)
    11789
                    let shift := sub(256, shl(3, length))
    11790
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11791
                }
    11792
                m0 := mload(0x00)
    11793
                m1 := mload(0x20)
    11794
                m2 := mload(0x40)
    11795
                m3 := mload(0x60)
    11796
                m4 := mload(0x80)
    11797
                m5 := mload(0xa0)
    11798
                m6 := mload(0xc0)
    11799
                // Selector of `log(string,bool,bool,uint256)`.
    11800
                mstore(0x00, 0x8e3f78a9)
    11801
                mstore(0x20, 0x80)
    11802
                mstore(0x40, p1)
    11803
                mstore(0x60, p2)
    11804
                mstore(0x80, p3)
    11805
                writeString(0xa0, p0)
    11806
            }
    11807
            _sendLogPayload(0x1c, 0xc4);
    11808
            /// @solidity memory-safe-assembly
    11809
            assembly {
    11810
                mstore(0x00, m0)
    11811
                mstore(0x20, m1)
    11812
                mstore(0x40, m2)
    11813
                mstore(0x60, m3)
    11814
                mstore(0x80, m4)
    11815
                mstore(0xa0, m5)
    11816
                mstore(0xc0, m6)
    11817
            }
    11818
        }
    11819
    
                                                    
                                                
    11820
        function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {
    11821
            bytes32 m0;
    11822
            bytes32 m1;
    11823
            bytes32 m2;
    11824
            bytes32 m3;
    11825
            bytes32 m4;
    11826
            bytes32 m5;
    11827
            bytes32 m6;
    11828
            bytes32 m7;
    11829
            bytes32 m8;
    11830
            /// @solidity memory-safe-assembly
    11831
            assembly {
    11832
                function writeString(pos, w) {
    11833
                    let length := 0
    11834
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11835
                    mstore(pos, length)
    11836
                    let shift := sub(256, shl(3, length))
    11837
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11838
                }
    11839
                m0 := mload(0x00)
    11840
                m1 := mload(0x20)
    11841
                m2 := mload(0x40)
    11842
                m3 := mload(0x60)
    11843
                m4 := mload(0x80)
    11844
                m5 := mload(0xa0)
    11845
                m6 := mload(0xc0)
    11846
                m7 := mload(0xe0)
    11847
                m8 := mload(0x100)
    11848
                // Selector of `log(string,bool,bool,string)`.
    11849
                mstore(0x00, 0x9d22d5dd)
    11850
                mstore(0x20, 0x80)
    11851
                mstore(0x40, p1)
    11852
                mstore(0x60, p2)
    11853
                mstore(0x80, 0xc0)
    11854
                writeString(0xa0, p0)
    11855
                writeString(0xe0, p3)
    11856
            }
    11857
            _sendLogPayload(0x1c, 0x104);
    11858
            /// @solidity memory-safe-assembly
    11859
            assembly {
    11860
                mstore(0x00, m0)
    11861
                mstore(0x20, m1)
    11862
                mstore(0x40, m2)
    11863
                mstore(0x60, m3)
    11864
                mstore(0x80, m4)
    11865
                mstore(0xa0, m5)
    11866
                mstore(0xc0, m6)
    11867
                mstore(0xe0, m7)
    11868
                mstore(0x100, m8)
    11869
            }
    11870
        }
    11871
    
                                                    
                                                
    11872
        function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {
    11873
            bytes32 m0;
    11874
            bytes32 m1;
    11875
            bytes32 m2;
    11876
            bytes32 m3;
    11877
            bytes32 m4;
    11878
            bytes32 m5;
    11879
            bytes32 m6;
    11880
            /// @solidity memory-safe-assembly
    11881
            assembly {
    11882
                function writeString(pos, w) {
    11883
                    let length := 0
    11884
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11885
                    mstore(pos, length)
    11886
                    let shift := sub(256, shl(3, length))
    11887
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11888
                }
    11889
                m0 := mload(0x00)
    11890
                m1 := mload(0x20)
    11891
                m2 := mload(0x40)
    11892
                m3 := mload(0x60)
    11893
                m4 := mload(0x80)
    11894
                m5 := mload(0xa0)
    11895
                m6 := mload(0xc0)
    11896
                // Selector of `log(string,bool,uint256,address)`.
    11897
                mstore(0x00, 0x935e09bf)
    11898
                mstore(0x20, 0x80)
    11899
                mstore(0x40, p1)
    11900
                mstore(0x60, p2)
    11901
                mstore(0x80, p3)
    11902
                writeString(0xa0, p0)
    11903
            }
    11904
            _sendLogPayload(0x1c, 0xc4);
    11905
            /// @solidity memory-safe-assembly
    11906
            assembly {
    11907
                mstore(0x00, m0)
    11908
                mstore(0x20, m1)
    11909
                mstore(0x40, m2)
    11910
                mstore(0x60, m3)
    11911
                mstore(0x80, m4)
    11912
                mstore(0xa0, m5)
    11913
                mstore(0xc0, m6)
    11914
            }
    11915
        }
    11916
    
                                                    
                                                
    11917
        function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {
    11918
            bytes32 m0;
    11919
            bytes32 m1;
    11920
            bytes32 m2;
    11921
            bytes32 m3;
    11922
            bytes32 m4;
    11923
            bytes32 m5;
    11924
            bytes32 m6;
    11925
            /// @solidity memory-safe-assembly
    11926
            assembly {
    11927
                function writeString(pos, w) {
    11928
                    let length := 0
    11929
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11930
                    mstore(pos, length)
    11931
                    let shift := sub(256, shl(3, length))
    11932
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11933
                }
    11934
                m0 := mload(0x00)
    11935
                m1 := mload(0x20)
    11936
                m2 := mload(0x40)
    11937
                m3 := mload(0x60)
    11938
                m4 := mload(0x80)
    11939
                m5 := mload(0xa0)
    11940
                m6 := mload(0xc0)
    11941
                // Selector of `log(string,bool,uint256,bool)`.
    11942
                mstore(0x00, 0x8af7cf8a)
    11943
                mstore(0x20, 0x80)
    11944
                mstore(0x40, p1)
    11945
                mstore(0x60, p2)
    11946
                mstore(0x80, p3)
    11947
                writeString(0xa0, p0)
    11948
            }
    11949
            _sendLogPayload(0x1c, 0xc4);
    11950
            /// @solidity memory-safe-assembly
    11951
            assembly {
    11952
                mstore(0x00, m0)
    11953
                mstore(0x20, m1)
    11954
                mstore(0x40, m2)
    11955
                mstore(0x60, m3)
    11956
                mstore(0x80, m4)
    11957
                mstore(0xa0, m5)
    11958
                mstore(0xc0, m6)
    11959
            }
    11960
        }
    11961
    
                                                    
                                                
    11962
        function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {
    11963
            bytes32 m0;
    11964
            bytes32 m1;
    11965
            bytes32 m2;
    11966
            bytes32 m3;
    11967
            bytes32 m4;
    11968
            bytes32 m5;
    11969
            bytes32 m6;
    11970
            /// @solidity memory-safe-assembly
    11971
            assembly {
    11972
                function writeString(pos, w) {
    11973
                    let length := 0
    11974
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11975
                    mstore(pos, length)
    11976
                    let shift := sub(256, shl(3, length))
    11977
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11978
                }
    11979
                m0 := mload(0x00)
    11980
                m1 := mload(0x20)
    11981
                m2 := mload(0x40)
    11982
                m3 := mload(0x60)
    11983
                m4 := mload(0x80)
    11984
                m5 := mload(0xa0)
    11985
                m6 := mload(0xc0)
    11986
                // Selector of `log(string,bool,uint256,uint256)`.
    11987
                mstore(0x00, 0x64b5bb67)
    11988
                mstore(0x20, 0x80)
    11989
                mstore(0x40, p1)
    11990
                mstore(0x60, p2)
    11991
                mstore(0x80, p3)
    11992
                writeString(0xa0, p0)
    11993
            }
    11994
            _sendLogPayload(0x1c, 0xc4);
    11995
            /// @solidity memory-safe-assembly
    11996
            assembly {
    11997
                mstore(0x00, m0)
    11998
                mstore(0x20, m1)
    11999
                mstore(0x40, m2)
    12000
                mstore(0x60, m3)
    12001
                mstore(0x80, m4)
    12002
                mstore(0xa0, m5)
    12003
                mstore(0xc0, m6)
    12004
            }
    12005
        }
    12006
    
                                                    
                                                
    12007
        function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    12008
            bytes32 m0;
    12009
            bytes32 m1;
    12010
            bytes32 m2;
    12011
            bytes32 m3;
    12012
            bytes32 m4;
    12013
            bytes32 m5;
    12014
            bytes32 m6;
    12015
            bytes32 m7;
    12016
            bytes32 m8;
    12017
            /// @solidity memory-safe-assembly
    12018
            assembly {
    12019
                function writeString(pos, w) {
    12020
                    let length := 0
    12021
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12022
                    mstore(pos, length)
    12023
                    let shift := sub(256, shl(3, length))
    12024
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12025
                }
    12026
                m0 := mload(0x00)
    12027
                m1 := mload(0x20)
    12028
                m2 := mload(0x40)
    12029
                m3 := mload(0x60)
    12030
                m4 := mload(0x80)
    12031
                m5 := mload(0xa0)
    12032
                m6 := mload(0xc0)
    12033
                m7 := mload(0xe0)
    12034
                m8 := mload(0x100)
    12035
                // Selector of `log(string,bool,uint256,string)`.
    12036
                mstore(0x00, 0x742d6ee7)
    12037
                mstore(0x20, 0x80)
    12038
                mstore(0x40, p1)
    12039
                mstore(0x60, p2)
    12040
                mstore(0x80, 0xc0)
    12041
                writeString(0xa0, p0)
    12042
                writeString(0xe0, p3)
    12043
            }
    12044
            _sendLogPayload(0x1c, 0x104);
    12045
            /// @solidity memory-safe-assembly
    12046
            assembly {
    12047
                mstore(0x00, m0)
    12048
                mstore(0x20, m1)
    12049
                mstore(0x40, m2)
    12050
                mstore(0x60, m3)
    12051
                mstore(0x80, m4)
    12052
                mstore(0xa0, m5)
    12053
                mstore(0xc0, m6)
    12054
                mstore(0xe0, m7)
    12055
                mstore(0x100, m8)
    12056
            }
    12057
        }
    12058
    
                                                    
                                                
    12059
        function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {
    12060
            bytes32 m0;
    12061
            bytes32 m1;
    12062
            bytes32 m2;
    12063
            bytes32 m3;
    12064
            bytes32 m4;
    12065
            bytes32 m5;
    12066
            bytes32 m6;
    12067
            bytes32 m7;
    12068
            bytes32 m8;
    12069
            /// @solidity memory-safe-assembly
    12070
            assembly {
    12071
                function writeString(pos, w) {
    12072
                    let length := 0
    12073
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12074
                    mstore(pos, length)
    12075
                    let shift := sub(256, shl(3, length))
    12076
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12077
                }
    12078
                m0 := mload(0x00)
    12079
                m1 := mload(0x20)
    12080
                m2 := mload(0x40)
    12081
                m3 := mload(0x60)
    12082
                m4 := mload(0x80)
    12083
                m5 := mload(0xa0)
    12084
                m6 := mload(0xc0)
    12085
                m7 := mload(0xe0)
    12086
                m8 := mload(0x100)
    12087
                // Selector of `log(string,bool,string,address)`.
    12088
                mstore(0x00, 0xe0625b29)
    12089
                mstore(0x20, 0x80)
    12090
                mstore(0x40, p1)
    12091
                mstore(0x60, 0xc0)
    12092
                mstore(0x80, p3)
    12093
                writeString(0xa0, p0)
    12094
                writeString(0xe0, p2)
    12095
            }
    12096
            _sendLogPayload(0x1c, 0x104);
    12097
            /// @solidity memory-safe-assembly
    12098
            assembly {
    12099
                mstore(0x00, m0)
    12100
                mstore(0x20, m1)
    12101
                mstore(0x40, m2)
    12102
                mstore(0x60, m3)
    12103
                mstore(0x80, m4)
    12104
                mstore(0xa0, m5)
    12105
                mstore(0xc0, m6)
    12106
                mstore(0xe0, m7)
    12107
                mstore(0x100, m8)
    12108
            }
    12109
        }
    12110
    
                                                    
                                                
    12111
        function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {
    12112
            bytes32 m0;
    12113
            bytes32 m1;
    12114
            bytes32 m2;
    12115
            bytes32 m3;
    12116
            bytes32 m4;
    12117
            bytes32 m5;
    12118
            bytes32 m6;
    12119
            bytes32 m7;
    12120
            bytes32 m8;
    12121
            /// @solidity memory-safe-assembly
    12122
            assembly {
    12123
                function writeString(pos, w) {
    12124
                    let length := 0
    12125
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12126
                    mstore(pos, length)
    12127
                    let shift := sub(256, shl(3, length))
    12128
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12129
                }
    12130
                m0 := mload(0x00)
    12131
                m1 := mload(0x20)
    12132
                m2 := mload(0x40)
    12133
                m3 := mload(0x60)
    12134
                m4 := mload(0x80)
    12135
                m5 := mload(0xa0)
    12136
                m6 := mload(0xc0)
    12137
                m7 := mload(0xe0)
    12138
                m8 := mload(0x100)
    12139
                // Selector of `log(string,bool,string,bool)`.
    12140
                mstore(0x00, 0x3f8a701d)
    12141
                mstore(0x20, 0x80)
    12142
                mstore(0x40, p1)
    12143
                mstore(0x60, 0xc0)
    12144
                mstore(0x80, p3)
    12145
                writeString(0xa0, p0)
    12146
                writeString(0xe0, p2)
    12147
            }
    12148
            _sendLogPayload(0x1c, 0x104);
    12149
            /// @solidity memory-safe-assembly
    12150
            assembly {
    12151
                mstore(0x00, m0)
    12152
                mstore(0x20, m1)
    12153
                mstore(0x40, m2)
    12154
                mstore(0x60, m3)
    12155
                mstore(0x80, m4)
    12156
                mstore(0xa0, m5)
    12157
                mstore(0xc0, m6)
    12158
                mstore(0xe0, m7)
    12159
                mstore(0x100, m8)
    12160
            }
    12161
        }
    12162
    
                                                    
                                                
    12163
        function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    12164
            bytes32 m0;
    12165
            bytes32 m1;
    12166
            bytes32 m2;
    12167
            bytes32 m3;
    12168
            bytes32 m4;
    12169
            bytes32 m5;
    12170
            bytes32 m6;
    12171
            bytes32 m7;
    12172
            bytes32 m8;
    12173
            /// @solidity memory-safe-assembly
    12174
            assembly {
    12175
                function writeString(pos, w) {
    12176
                    let length := 0
    12177
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12178
                    mstore(pos, length)
    12179
                    let shift := sub(256, shl(3, length))
    12180
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12181
                }
    12182
                m0 := mload(0x00)
    12183
                m1 := mload(0x20)
    12184
                m2 := mload(0x40)
    12185
                m3 := mload(0x60)
    12186
                m4 := mload(0x80)
    12187
                m5 := mload(0xa0)
    12188
                m6 := mload(0xc0)
    12189
                m7 := mload(0xe0)
    12190
                m8 := mload(0x100)
    12191
                // Selector of `log(string,bool,string,uint256)`.
    12192
                mstore(0x00, 0x24f91465)
    12193
                mstore(0x20, 0x80)
    12194
                mstore(0x40, p1)
    12195
                mstore(0x60, 0xc0)
    12196
                mstore(0x80, p3)
    12197
                writeString(0xa0, p0)
    12198
                writeString(0xe0, p2)
    12199
            }
    12200
            _sendLogPayload(0x1c, 0x104);
    12201
            /// @solidity memory-safe-assembly
    12202
            assembly {
    12203
                mstore(0x00, m0)
    12204
                mstore(0x20, m1)
    12205
                mstore(0x40, m2)
    12206
                mstore(0x60, m3)
    12207
                mstore(0x80, m4)
    12208
                mstore(0xa0, m5)
    12209
                mstore(0xc0, m6)
    12210
                mstore(0xe0, m7)
    12211
                mstore(0x100, m8)
    12212
            }
    12213
        }
    12214
    
                                                    
                                                
    12215
        function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    12216
            bytes32 m0;
    12217
            bytes32 m1;
    12218
            bytes32 m2;
    12219
            bytes32 m3;
    12220
            bytes32 m4;
    12221
            bytes32 m5;
    12222
            bytes32 m6;
    12223
            bytes32 m7;
    12224
            bytes32 m8;
    12225
            bytes32 m9;
    12226
            bytes32 m10;
    12227
            /// @solidity memory-safe-assembly
    12228
            assembly {
    12229
                function writeString(pos, w) {
    12230
                    let length := 0
    12231
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12232
                    mstore(pos, length)
    12233
                    let shift := sub(256, shl(3, length))
    12234
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12235
                }
    12236
                m0 := mload(0x00)
    12237
                m1 := mload(0x20)
    12238
                m2 := mload(0x40)
    12239
                m3 := mload(0x60)
    12240
                m4 := mload(0x80)
    12241
                m5 := mload(0xa0)
    12242
                m6 := mload(0xc0)
    12243
                m7 := mload(0xe0)
    12244
                m8 := mload(0x100)
    12245
                m9 := mload(0x120)
    12246
                m10 := mload(0x140)
    12247
                // Selector of `log(string,bool,string,string)`.
    12248
                mstore(0x00, 0xa826caeb)
    12249
                mstore(0x20, 0x80)
    12250
                mstore(0x40, p1)
    12251
                mstore(0x60, 0xc0)
    12252
                mstore(0x80, 0x100)
    12253
                writeString(0xa0, p0)
    12254
                writeString(0xe0, p2)
    12255
                writeString(0x120, p3)
    12256
            }
    12257
            _sendLogPayload(0x1c, 0x144);
    12258
            /// @solidity memory-safe-assembly
    12259
            assembly {
    12260
                mstore(0x00, m0)
    12261
                mstore(0x20, m1)
    12262
                mstore(0x40, m2)
    12263
                mstore(0x60, m3)
    12264
                mstore(0x80, m4)
    12265
                mstore(0xa0, m5)
    12266
                mstore(0xc0, m6)
    12267
                mstore(0xe0, m7)
    12268
                mstore(0x100, m8)
    12269
                mstore(0x120, m9)
    12270
                mstore(0x140, m10)
    12271
            }
    12272
        }
    12273
    
                                                    
                                                
    12274
        function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {
    12275
            bytes32 m0;
    12276
            bytes32 m1;
    12277
            bytes32 m2;
    12278
            bytes32 m3;
    12279
            bytes32 m4;
    12280
            bytes32 m5;
    12281
            bytes32 m6;
    12282
            /// @solidity memory-safe-assembly
    12283
            assembly {
    12284
                function writeString(pos, w) {
    12285
                    let length := 0
    12286
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12287
                    mstore(pos, length)
    12288
                    let shift := sub(256, shl(3, length))
    12289
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12290
                }
    12291
                m0 := mload(0x00)
    12292
                m1 := mload(0x20)
    12293
                m2 := mload(0x40)
    12294
                m3 := mload(0x60)
    12295
                m4 := mload(0x80)
    12296
                m5 := mload(0xa0)
    12297
                m6 := mload(0xc0)
    12298
                // Selector of `log(string,uint256,address,address)`.
    12299
                mstore(0x00, 0x5ea2b7ae)
    12300
                mstore(0x20, 0x80)
    12301
                mstore(0x40, p1)
    12302
                mstore(0x60, p2)
    12303
                mstore(0x80, p3)
    12304
                writeString(0xa0, p0)
    12305
            }
    12306
            _sendLogPayload(0x1c, 0xc4);
    12307
            /// @solidity memory-safe-assembly
    12308
            assembly {
    12309
                mstore(0x00, m0)
    12310
                mstore(0x20, m1)
    12311
                mstore(0x40, m2)
    12312
                mstore(0x60, m3)
    12313
                mstore(0x80, m4)
    12314
                mstore(0xa0, m5)
    12315
                mstore(0xc0, m6)
    12316
            }
    12317
        }
    12318
    
                                                    
                                                
    12319
        function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {
    12320
            bytes32 m0;
    12321
            bytes32 m1;
    12322
            bytes32 m2;
    12323
            bytes32 m3;
    12324
            bytes32 m4;
    12325
            bytes32 m5;
    12326
            bytes32 m6;
    12327
            /// @solidity memory-safe-assembly
    12328
            assembly {
    12329
                function writeString(pos, w) {
    12330
                    let length := 0
    12331
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12332
                    mstore(pos, length)
    12333
                    let shift := sub(256, shl(3, length))
    12334
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12335
                }
    12336
                m0 := mload(0x00)
    12337
                m1 := mload(0x20)
    12338
                m2 := mload(0x40)
    12339
                m3 := mload(0x60)
    12340
                m4 := mload(0x80)
    12341
                m5 := mload(0xa0)
    12342
                m6 := mload(0xc0)
    12343
                // Selector of `log(string,uint256,address,bool)`.
    12344
                mstore(0x00, 0x82112a42)
    12345
                mstore(0x20, 0x80)
    12346
                mstore(0x40, p1)
    12347
                mstore(0x60, p2)
    12348
                mstore(0x80, p3)
    12349
                writeString(0xa0, p0)
    12350
            }
    12351
            _sendLogPayload(0x1c, 0xc4);
    12352
            /// @solidity memory-safe-assembly
    12353
            assembly {
    12354
                mstore(0x00, m0)
    12355
                mstore(0x20, m1)
    12356
                mstore(0x40, m2)
    12357
                mstore(0x60, m3)
    12358
                mstore(0x80, m4)
    12359
                mstore(0xa0, m5)
    12360
                mstore(0xc0, m6)
    12361
            }
    12362
        }
    12363
    
                                                    
                                                
    12364
        function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {
    12365
            bytes32 m0;
    12366
            bytes32 m1;
    12367
            bytes32 m2;
    12368
            bytes32 m3;
    12369
            bytes32 m4;
    12370
            bytes32 m5;
    12371
            bytes32 m6;
    12372
            /// @solidity memory-safe-assembly
    12373
            assembly {
    12374
                function writeString(pos, w) {
    12375
                    let length := 0
    12376
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12377
                    mstore(pos, length)
    12378
                    let shift := sub(256, shl(3, length))
    12379
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12380
                }
    12381
                m0 := mload(0x00)
    12382
                m1 := mload(0x20)
    12383
                m2 := mload(0x40)
    12384
                m3 := mload(0x60)
    12385
                m4 := mload(0x80)
    12386
                m5 := mload(0xa0)
    12387
                m6 := mload(0xc0)
    12388
                // Selector of `log(string,uint256,address,uint256)`.
    12389
                mstore(0x00, 0x4f04fdc6)
    12390
                mstore(0x20, 0x80)
    12391
                mstore(0x40, p1)
    12392
                mstore(0x60, p2)
    12393
                mstore(0x80, p3)
    12394
                writeString(0xa0, p0)
    12395
            }
    12396
            _sendLogPayload(0x1c, 0xc4);
    12397
            /// @solidity memory-safe-assembly
    12398
            assembly {
    12399
                mstore(0x00, m0)
    12400
                mstore(0x20, m1)
    12401
                mstore(0x40, m2)
    12402
                mstore(0x60, m3)
    12403
                mstore(0x80, m4)
    12404
                mstore(0xa0, m5)
    12405
                mstore(0xc0, m6)
    12406
            }
    12407
        }
    12408
    
                                                    
                                                
    12409
        function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {
    12410
            bytes32 m0;
    12411
            bytes32 m1;
    12412
            bytes32 m2;
    12413
            bytes32 m3;
    12414
            bytes32 m4;
    12415
            bytes32 m5;
    12416
            bytes32 m6;
    12417
            bytes32 m7;
    12418
            bytes32 m8;
    12419
            /// @solidity memory-safe-assembly
    12420
            assembly {
    12421
                function writeString(pos, w) {
    12422
                    let length := 0
    12423
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12424
                    mstore(pos, length)
    12425
                    let shift := sub(256, shl(3, length))
    12426
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12427
                }
    12428
                m0 := mload(0x00)
    12429
                m1 := mload(0x20)
    12430
                m2 := mload(0x40)
    12431
                m3 := mload(0x60)
    12432
                m4 := mload(0x80)
    12433
                m5 := mload(0xa0)
    12434
                m6 := mload(0xc0)
    12435
                m7 := mload(0xe0)
    12436
                m8 := mload(0x100)
    12437
                // Selector of `log(string,uint256,address,string)`.
    12438
                mstore(0x00, 0x9ffb2f93)
    12439
                mstore(0x20, 0x80)
    12440
                mstore(0x40, p1)
    12441
                mstore(0x60, p2)
    12442
                mstore(0x80, 0xc0)
    12443
                writeString(0xa0, p0)
    12444
                writeString(0xe0, p3)
    12445
            }
    12446
            _sendLogPayload(0x1c, 0x104);
    12447
            /// @solidity memory-safe-assembly
    12448
            assembly {
    12449
                mstore(0x00, m0)
    12450
                mstore(0x20, m1)
    12451
                mstore(0x40, m2)
    12452
                mstore(0x60, m3)
    12453
                mstore(0x80, m4)
    12454
                mstore(0xa0, m5)
    12455
                mstore(0xc0, m6)
    12456
                mstore(0xe0, m7)
    12457
                mstore(0x100, m8)
    12458
            }
    12459
        }
    12460
    
                                                    
                                                
    12461
        function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {
    12462
            bytes32 m0;
    12463
            bytes32 m1;
    12464
            bytes32 m2;
    12465
            bytes32 m3;
    12466
            bytes32 m4;
    12467
            bytes32 m5;
    12468
            bytes32 m6;
    12469
            /// @solidity memory-safe-assembly
    12470
            assembly {
    12471
                function writeString(pos, w) {
    12472
                    let length := 0
    12473
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12474
                    mstore(pos, length)
    12475
                    let shift := sub(256, shl(3, length))
    12476
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12477
                }
    12478
                m0 := mload(0x00)
    12479
                m1 := mload(0x20)
    12480
                m2 := mload(0x40)
    12481
                m3 := mload(0x60)
    12482
                m4 := mload(0x80)
    12483
                m5 := mload(0xa0)
    12484
                m6 := mload(0xc0)
    12485
                // Selector of `log(string,uint256,bool,address)`.
    12486
                mstore(0x00, 0xe0e95b98)
    12487
                mstore(0x20, 0x80)
    12488
                mstore(0x40, p1)
    12489
                mstore(0x60, p2)
    12490
                mstore(0x80, p3)
    12491
                writeString(0xa0, p0)
    12492
            }
    12493
            _sendLogPayload(0x1c, 0xc4);
    12494
            /// @solidity memory-safe-assembly
    12495
            assembly {
    12496
                mstore(0x00, m0)
    12497
                mstore(0x20, m1)
    12498
                mstore(0x40, m2)
    12499
                mstore(0x60, m3)
    12500
                mstore(0x80, m4)
    12501
                mstore(0xa0, m5)
    12502
                mstore(0xc0, m6)
    12503
            }
    12504
        }
    12505
    
                                                    
                                                
    12506
        function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {
    12507
            bytes32 m0;
    12508
            bytes32 m1;
    12509
            bytes32 m2;
    12510
            bytes32 m3;
    12511
            bytes32 m4;
    12512
            bytes32 m5;
    12513
            bytes32 m6;
    12514
            /// @solidity memory-safe-assembly
    12515
            assembly {
    12516
                function writeString(pos, w) {
    12517
                    let length := 0
    12518
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12519
                    mstore(pos, length)
    12520
                    let shift := sub(256, shl(3, length))
    12521
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12522
                }
    12523
                m0 := mload(0x00)
    12524
                m1 := mload(0x20)
    12525
                m2 := mload(0x40)
    12526
                m3 := mload(0x60)
    12527
                m4 := mload(0x80)
    12528
                m5 := mload(0xa0)
    12529
                m6 := mload(0xc0)
    12530
                // Selector of `log(string,uint256,bool,bool)`.
    12531
                mstore(0x00, 0x354c36d6)
    12532
                mstore(0x20, 0x80)
    12533
                mstore(0x40, p1)
    12534
                mstore(0x60, p2)
    12535
                mstore(0x80, p3)
    12536
                writeString(0xa0, p0)
    12537
            }
    12538
            _sendLogPayload(0x1c, 0xc4);
    12539
            /// @solidity memory-safe-assembly
    12540
            assembly {
    12541
                mstore(0x00, m0)
    12542
                mstore(0x20, m1)
    12543
                mstore(0x40, m2)
    12544
                mstore(0x60, m3)
    12545
                mstore(0x80, m4)
    12546
                mstore(0xa0, m5)
    12547
                mstore(0xc0, m6)
    12548
            }
    12549
        }
    12550
    
                                                    
                                                
    12551
        function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {
    12552
            bytes32 m0;
    12553
            bytes32 m1;
    12554
            bytes32 m2;
    12555
            bytes32 m3;
    12556
            bytes32 m4;
    12557
            bytes32 m5;
    12558
            bytes32 m6;
    12559
            /// @solidity memory-safe-assembly
    12560
            assembly {
    12561
                function writeString(pos, w) {
    12562
                    let length := 0
    12563
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12564
                    mstore(pos, length)
    12565
                    let shift := sub(256, shl(3, length))
    12566
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12567
                }
    12568
                m0 := mload(0x00)
    12569
                m1 := mload(0x20)
    12570
                m2 := mload(0x40)
    12571
                m3 := mload(0x60)
    12572
                m4 := mload(0x80)
    12573
                m5 := mload(0xa0)
    12574
                m6 := mload(0xc0)
    12575
                // Selector of `log(string,uint256,bool,uint256)`.
    12576
                mstore(0x00, 0xe41b6f6f)
    12577
                mstore(0x20, 0x80)
    12578
                mstore(0x40, p1)
    12579
                mstore(0x60, p2)
    12580
                mstore(0x80, p3)
    12581
                writeString(0xa0, p0)
    12582
            }
    12583
            _sendLogPayload(0x1c, 0xc4);
    12584
            /// @solidity memory-safe-assembly
    12585
            assembly {
    12586
                mstore(0x00, m0)
    12587
                mstore(0x20, m1)
    12588
                mstore(0x40, m2)
    12589
                mstore(0x60, m3)
    12590
                mstore(0x80, m4)
    12591
                mstore(0xa0, m5)
    12592
                mstore(0xc0, m6)
    12593
            }
    12594
        }
    12595
    
                                                    
                                                
    12596
        function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    12597
            bytes32 m0;
    12598
            bytes32 m1;
    12599
            bytes32 m2;
    12600
            bytes32 m3;
    12601
            bytes32 m4;
    12602
            bytes32 m5;
    12603
            bytes32 m6;
    12604
            bytes32 m7;
    12605
            bytes32 m8;
    12606
            /// @solidity memory-safe-assembly
    12607
            assembly {
    12608
                function writeString(pos, w) {
    12609
                    let length := 0
    12610
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12611
                    mstore(pos, length)
    12612
                    let shift := sub(256, shl(3, length))
    12613
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12614
                }
    12615
                m0 := mload(0x00)
    12616
                m1 := mload(0x20)
    12617
                m2 := mload(0x40)
    12618
                m3 := mload(0x60)
    12619
                m4 := mload(0x80)
    12620
                m5 := mload(0xa0)
    12621
                m6 := mload(0xc0)
    12622
                m7 := mload(0xe0)
    12623
                m8 := mload(0x100)
    12624
                // Selector of `log(string,uint256,bool,string)`.
    12625
                mstore(0x00, 0xabf73a98)
    12626
                mstore(0x20, 0x80)
    12627
                mstore(0x40, p1)
    12628
                mstore(0x60, p2)
    12629
                mstore(0x80, 0xc0)
    12630
                writeString(0xa0, p0)
    12631
                writeString(0xe0, p3)
    12632
            }
    12633
            _sendLogPayload(0x1c, 0x104);
    12634
            /// @solidity memory-safe-assembly
    12635
            assembly {
    12636
                mstore(0x00, m0)
    12637
                mstore(0x20, m1)
    12638
                mstore(0x40, m2)
    12639
                mstore(0x60, m3)
    12640
                mstore(0x80, m4)
    12641
                mstore(0xa0, m5)
    12642
                mstore(0xc0, m6)
    12643
                mstore(0xe0, m7)
    12644
                mstore(0x100, m8)
    12645
            }
    12646
        }
    12647
    
                                                    
                                                
    12648
        function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {
    12649
            bytes32 m0;
    12650
            bytes32 m1;
    12651
            bytes32 m2;
    12652
            bytes32 m3;
    12653
            bytes32 m4;
    12654
            bytes32 m5;
    12655
            bytes32 m6;
    12656
            /// @solidity memory-safe-assembly
    12657
            assembly {
    12658
                function writeString(pos, w) {
    12659
                    let length := 0
    12660
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12661
                    mstore(pos, length)
    12662
                    let shift := sub(256, shl(3, length))
    12663
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12664
                }
    12665
                m0 := mload(0x00)
    12666
                m1 := mload(0x20)
    12667
                m2 := mload(0x40)
    12668
                m3 := mload(0x60)
    12669
                m4 := mload(0x80)
    12670
                m5 := mload(0xa0)
    12671
                m6 := mload(0xc0)
    12672
                // Selector of `log(string,uint256,uint256,address)`.
    12673
                mstore(0x00, 0xe21de278)
    12674
                mstore(0x20, 0x80)
    12675
                mstore(0x40, p1)
    12676
                mstore(0x60, p2)
    12677
                mstore(0x80, p3)
    12678
                writeString(0xa0, p0)
    12679
            }
    12680
            _sendLogPayload(0x1c, 0xc4);
    12681
            /// @solidity memory-safe-assembly
    12682
            assembly {
    12683
                mstore(0x00, m0)
    12684
                mstore(0x20, m1)
    12685
                mstore(0x40, m2)
    12686
                mstore(0x60, m3)
    12687
                mstore(0x80, m4)
    12688
                mstore(0xa0, m5)
    12689
                mstore(0xc0, m6)
    12690
            }
    12691
        }
    12692
    
                                                    
                                                
    12693
        function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {
    12694
            bytes32 m0;
    12695
            bytes32 m1;
    12696
            bytes32 m2;
    12697
            bytes32 m3;
    12698
            bytes32 m4;
    12699
            bytes32 m5;
    12700
            bytes32 m6;
    12701
            /// @solidity memory-safe-assembly
    12702
            assembly {
    12703
                function writeString(pos, w) {
    12704
                    let length := 0
    12705
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12706
                    mstore(pos, length)
    12707
                    let shift := sub(256, shl(3, length))
    12708
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12709
                }
    12710
                m0 := mload(0x00)
    12711
                m1 := mload(0x20)
    12712
                m2 := mload(0x40)
    12713
                m3 := mload(0x60)
    12714
                m4 := mload(0x80)
    12715
                m5 := mload(0xa0)
    12716
                m6 := mload(0xc0)
    12717
                // Selector of `log(string,uint256,uint256,bool)`.
    12718
                mstore(0x00, 0x7626db92)
    12719
                mstore(0x20, 0x80)
    12720
                mstore(0x40, p1)
    12721
                mstore(0x60, p2)
    12722
                mstore(0x80, p3)
    12723
                writeString(0xa0, p0)
    12724
            }
    12725
            _sendLogPayload(0x1c, 0xc4);
    12726
            /// @solidity memory-safe-assembly
    12727
            assembly {
    12728
                mstore(0x00, m0)
    12729
                mstore(0x20, m1)
    12730
                mstore(0x40, m2)
    12731
                mstore(0x60, m3)
    12732
                mstore(0x80, m4)
    12733
                mstore(0xa0, m5)
    12734
                mstore(0xc0, m6)
    12735
            }
    12736
        }
    12737
    
                                                    
                                                
    12738
        function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    12739
            bytes32 m0;
    12740
            bytes32 m1;
    12741
            bytes32 m2;
    12742
            bytes32 m3;
    12743
            bytes32 m4;
    12744
            bytes32 m5;
    12745
            bytes32 m6;
    12746
            /// @solidity memory-safe-assembly
    12747
            assembly {
    12748
                function writeString(pos, w) {
    12749
                    let length := 0
    12750
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12751
                    mstore(pos, length)
    12752
                    let shift := sub(256, shl(3, length))
    12753
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12754
                }
    12755
                m0 := mload(0x00)
    12756
                m1 := mload(0x20)
    12757
                m2 := mload(0x40)
    12758
                m3 := mload(0x60)
    12759
                m4 := mload(0x80)
    12760
                m5 := mload(0xa0)
    12761
                m6 := mload(0xc0)
    12762
                // Selector of `log(string,uint256,uint256,uint256)`.
    12763
                mstore(0x00, 0xa7a87853)
    12764
                mstore(0x20, 0x80)
    12765
                mstore(0x40, p1)
    12766
                mstore(0x60, p2)
    12767
                mstore(0x80, p3)
    12768
                writeString(0xa0, p0)
    12769
            }
    12770
            _sendLogPayload(0x1c, 0xc4);
    12771
            /// @solidity memory-safe-assembly
    12772
            assembly {
    12773
                mstore(0x00, m0)
    12774
                mstore(0x20, m1)
    12775
                mstore(0x40, m2)
    12776
                mstore(0x60, m3)
    12777
                mstore(0x80, m4)
    12778
                mstore(0xa0, m5)
    12779
                mstore(0xc0, m6)
    12780
            }
    12781
        }
    12782
    
                                                    
                                                
    12783
        function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    12784
            bytes32 m0;
    12785
            bytes32 m1;
    12786
            bytes32 m2;
    12787
            bytes32 m3;
    12788
            bytes32 m4;
    12789
            bytes32 m5;
    12790
            bytes32 m6;
    12791
            bytes32 m7;
    12792
            bytes32 m8;
    12793
            /// @solidity memory-safe-assembly
    12794
            assembly {
    12795
                function writeString(pos, w) {
    12796
                    let length := 0
    12797
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12798
                    mstore(pos, length)
    12799
                    let shift := sub(256, shl(3, length))
    12800
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12801
                }
    12802
                m0 := mload(0x00)
    12803
                m1 := mload(0x20)
    12804
                m2 := mload(0x40)
    12805
                m3 := mload(0x60)
    12806
                m4 := mload(0x80)
    12807
                m5 := mload(0xa0)
    12808
                m6 := mload(0xc0)
    12809
                m7 := mload(0xe0)
    12810
                m8 := mload(0x100)
    12811
                // Selector of `log(string,uint256,uint256,string)`.
    12812
                mstore(0x00, 0x854b3496)
    12813
                mstore(0x20, 0x80)
    12814
                mstore(0x40, p1)
    12815
                mstore(0x60, p2)
    12816
                mstore(0x80, 0xc0)
    12817
                writeString(0xa0, p0)
    12818
                writeString(0xe0, p3)
    12819
            }
    12820
            _sendLogPayload(0x1c, 0x104);
    12821
            /// @solidity memory-safe-assembly
    12822
            assembly {
    12823
                mstore(0x00, m0)
    12824
                mstore(0x20, m1)
    12825
                mstore(0x40, m2)
    12826
                mstore(0x60, m3)
    12827
                mstore(0x80, m4)
    12828
                mstore(0xa0, m5)
    12829
                mstore(0xc0, m6)
    12830
                mstore(0xe0, m7)
    12831
                mstore(0x100, m8)
    12832
            }
    12833
        }
    12834
    
                                                    
                                                
    12835
        function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {
    12836
            bytes32 m0;
    12837
            bytes32 m1;
    12838
            bytes32 m2;
    12839
            bytes32 m3;
    12840
            bytes32 m4;
    12841
            bytes32 m5;
    12842
            bytes32 m6;
    12843
            bytes32 m7;
    12844
            bytes32 m8;
    12845
            /// @solidity memory-safe-assembly
    12846
            assembly {
    12847
                function writeString(pos, w) {
    12848
                    let length := 0
    12849
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12850
                    mstore(pos, length)
    12851
                    let shift := sub(256, shl(3, length))
    12852
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12853
                }
    12854
                m0 := mload(0x00)
    12855
                m1 := mload(0x20)
    12856
                m2 := mload(0x40)
    12857
                m3 := mload(0x60)
    12858
                m4 := mload(0x80)
    12859
                m5 := mload(0xa0)
    12860
                m6 := mload(0xc0)
    12861
                m7 := mload(0xe0)
    12862
                m8 := mload(0x100)
    12863
                // Selector of `log(string,uint256,string,address)`.
    12864
                mstore(0x00, 0x7c4632a4)
    12865
                mstore(0x20, 0x80)
    12866
                mstore(0x40, p1)
    12867
                mstore(0x60, 0xc0)
    12868
                mstore(0x80, p3)
    12869
                writeString(0xa0, p0)
    12870
                writeString(0xe0, p2)
    12871
            }
    12872
            _sendLogPayload(0x1c, 0x104);
    12873
            /// @solidity memory-safe-assembly
    12874
            assembly {
    12875
                mstore(0x00, m0)
    12876
                mstore(0x20, m1)
    12877
                mstore(0x40, m2)
    12878
                mstore(0x60, m3)
    12879
                mstore(0x80, m4)
    12880
                mstore(0xa0, m5)
    12881
                mstore(0xc0, m6)
    12882
                mstore(0xe0, m7)
    12883
                mstore(0x100, m8)
    12884
            }
    12885
        }
    12886
    
                                                    
                                                
    12887
        function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    12888
            bytes32 m0;
    12889
            bytes32 m1;
    12890
            bytes32 m2;
    12891
            bytes32 m3;
    12892
            bytes32 m4;
    12893
            bytes32 m5;
    12894
            bytes32 m6;
    12895
            bytes32 m7;
    12896
            bytes32 m8;
    12897
            /// @solidity memory-safe-assembly
    12898
            assembly {
    12899
                function writeString(pos, w) {
    12900
                    let length := 0
    12901
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12902
                    mstore(pos, length)
    12903
                    let shift := sub(256, shl(3, length))
    12904
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12905
                }
    12906
                m0 := mload(0x00)
    12907
                m1 := mload(0x20)
    12908
                m2 := mload(0x40)
    12909
                m3 := mload(0x60)
    12910
                m4 := mload(0x80)
    12911
                m5 := mload(0xa0)
    12912
                m6 := mload(0xc0)
    12913
                m7 := mload(0xe0)
    12914
                m8 := mload(0x100)
    12915
                // Selector of `log(string,uint256,string,bool)`.
    12916
                mstore(0x00, 0x7d24491d)
    12917
                mstore(0x20, 0x80)
    12918
                mstore(0x40, p1)
    12919
                mstore(0x60, 0xc0)
    12920
                mstore(0x80, p3)
    12921
                writeString(0xa0, p0)
    12922
                writeString(0xe0, p2)
    12923
            }
    12924
            _sendLogPayload(0x1c, 0x104);
    12925
            /// @solidity memory-safe-assembly
    12926
            assembly {
    12927
                mstore(0x00, m0)
    12928
                mstore(0x20, m1)
    12929
                mstore(0x40, m2)
    12930
                mstore(0x60, m3)
    12931
                mstore(0x80, m4)
    12932
                mstore(0xa0, m5)
    12933
                mstore(0xc0, m6)
    12934
                mstore(0xe0, m7)
    12935
                mstore(0x100, m8)
    12936
            }
    12937
        }
    12938
    
                                                    
                                                
    12939
        function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    12940
            bytes32 m0;
    12941
            bytes32 m1;
    12942
            bytes32 m2;
    12943
            bytes32 m3;
    12944
            bytes32 m4;
    12945
            bytes32 m5;
    12946
            bytes32 m6;
    12947
            bytes32 m7;
    12948
            bytes32 m8;
    12949
            /// @solidity memory-safe-assembly
    12950
            assembly {
    12951
                function writeString(pos, w) {
    12952
                    let length := 0
    12953
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12954
                    mstore(pos, length)
    12955
                    let shift := sub(256, shl(3, length))
    12956
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12957
                }
    12958
                m0 := mload(0x00)
    12959
                m1 := mload(0x20)
    12960
                m2 := mload(0x40)
    12961
                m3 := mload(0x60)
    12962
                m4 := mload(0x80)
    12963
                m5 := mload(0xa0)
    12964
                m6 := mload(0xc0)
    12965
                m7 := mload(0xe0)
    12966
                m8 := mload(0x100)
    12967
                // Selector of `log(string,uint256,string,uint256)`.
    12968
                mstore(0x00, 0xc67ea9d1)
    12969
                mstore(0x20, 0x80)
    12970
                mstore(0x40, p1)
    12971
                mstore(0x60, 0xc0)
    12972
                mstore(0x80, p3)
    12973
                writeString(0xa0, p0)
    12974
                writeString(0xe0, p2)
    12975
            }
    12976
            _sendLogPayload(0x1c, 0x104);
    12977
            /// @solidity memory-safe-assembly
    12978
            assembly {
    12979
                mstore(0x00, m0)
    12980
                mstore(0x20, m1)
    12981
                mstore(0x40, m2)
    12982
                mstore(0x60, m3)
    12983
                mstore(0x80, m4)
    12984
                mstore(0xa0, m5)
    12985
                mstore(0xc0, m6)
    12986
                mstore(0xe0, m7)
    12987
                mstore(0x100, m8)
    12988
            }
    12989
        }
    12990
    
                                                    
                                                
    12991
        function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    12992
            bytes32 m0;
    12993
            bytes32 m1;
    12994
            bytes32 m2;
    12995
            bytes32 m3;
    12996
            bytes32 m4;
    12997
            bytes32 m5;
    12998
            bytes32 m6;
    12999
            bytes32 m7;
    13000
            bytes32 m8;
    13001
            bytes32 m9;
    13002
            bytes32 m10;
    13003
            /// @solidity memory-safe-assembly
    13004
            assembly {
    13005
                function writeString(pos, w) {
    13006
                    let length := 0
    13007
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13008
                    mstore(pos, length)
    13009
                    let shift := sub(256, shl(3, length))
    13010
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13011
                }
    13012
                m0 := mload(0x00)
    13013
                m1 := mload(0x20)
    13014
                m2 := mload(0x40)
    13015
                m3 := mload(0x60)
    13016
                m4 := mload(0x80)
    13017
                m5 := mload(0xa0)
    13018
                m6 := mload(0xc0)
    13019
                m7 := mload(0xe0)
    13020
                m8 := mload(0x100)
    13021
                m9 := mload(0x120)
    13022
                m10 := mload(0x140)
    13023
                // Selector of `log(string,uint256,string,string)`.
    13024
                mstore(0x00, 0x5ab84e1f)
    13025
                mstore(0x20, 0x80)
    13026
                mstore(0x40, p1)
    13027
                mstore(0x60, 0xc0)
    13028
                mstore(0x80, 0x100)
    13029
                writeString(0xa0, p0)
    13030
                writeString(0xe0, p2)
    13031
                writeString(0x120, p3)
    13032
            }
    13033
            _sendLogPayload(0x1c, 0x144);
    13034
            /// @solidity memory-safe-assembly
    13035
            assembly {
    13036
                mstore(0x00, m0)
    13037
                mstore(0x20, m1)
    13038
                mstore(0x40, m2)
    13039
                mstore(0x60, m3)
    13040
                mstore(0x80, m4)
    13041
                mstore(0xa0, m5)
    13042
                mstore(0xc0, m6)
    13043
                mstore(0xe0, m7)
    13044
                mstore(0x100, m8)
    13045
                mstore(0x120, m9)
    13046
                mstore(0x140, m10)
    13047
            }
    13048
        }
    13049
    
                                                    
                                                
    13050
        function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {
    13051
            bytes32 m0;
    13052
            bytes32 m1;
    13053
            bytes32 m2;
    13054
            bytes32 m3;
    13055
            bytes32 m4;
    13056
            bytes32 m5;
    13057
            bytes32 m6;
    13058
            bytes32 m7;
    13059
            bytes32 m8;
    13060
            /// @solidity memory-safe-assembly
    13061
            assembly {
    13062
                function writeString(pos, w) {
    13063
                    let length := 0
    13064
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13065
                    mstore(pos, length)
    13066
                    let shift := sub(256, shl(3, length))
    13067
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13068
                }
    13069
                m0 := mload(0x00)
    13070
                m1 := mload(0x20)
    13071
                m2 := mload(0x40)
    13072
                m3 := mload(0x60)
    13073
                m4 := mload(0x80)
    13074
                m5 := mload(0xa0)
    13075
                m6 := mload(0xc0)
    13076
                m7 := mload(0xe0)
    13077
                m8 := mload(0x100)
    13078
                // Selector of `log(string,string,address,address)`.
    13079
                mstore(0x00, 0x439c7bef)
    13080
                mstore(0x20, 0x80)
    13081
                mstore(0x40, 0xc0)
    13082
                mstore(0x60, p2)
    13083
                mstore(0x80, p3)
    13084
                writeString(0xa0, p0)
    13085
                writeString(0xe0, p1)
    13086
            }
    13087
            _sendLogPayload(0x1c, 0x104);
    13088
            /// @solidity memory-safe-assembly
    13089
            assembly {
    13090
                mstore(0x00, m0)
    13091
                mstore(0x20, m1)
    13092
                mstore(0x40, m2)
    13093
                mstore(0x60, m3)
    13094
                mstore(0x80, m4)
    13095
                mstore(0xa0, m5)
    13096
                mstore(0xc0, m6)
    13097
                mstore(0xe0, m7)
    13098
                mstore(0x100, m8)
    13099
            }
    13100
        }
    13101
    
                                                    
                                                
    13102
        function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {
    13103
            bytes32 m0;
    13104
            bytes32 m1;
    13105
            bytes32 m2;
    13106
            bytes32 m3;
    13107
            bytes32 m4;
    13108
            bytes32 m5;
    13109
            bytes32 m6;
    13110
            bytes32 m7;
    13111
            bytes32 m8;
    13112
            /// @solidity memory-safe-assembly
    13113
            assembly {
    13114
                function writeString(pos, w) {
    13115
                    let length := 0
    13116
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13117
                    mstore(pos, length)
    13118
                    let shift := sub(256, shl(3, length))
    13119
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13120
                }
    13121
                m0 := mload(0x00)
    13122
                m1 := mload(0x20)
    13123
                m2 := mload(0x40)
    13124
                m3 := mload(0x60)
    13125
                m4 := mload(0x80)
    13126
                m5 := mload(0xa0)
    13127
                m6 := mload(0xc0)
    13128
                m7 := mload(0xe0)
    13129
                m8 := mload(0x100)
    13130
                // Selector of `log(string,string,address,bool)`.
    13131
                mstore(0x00, 0x5ccd4e37)
    13132
                mstore(0x20, 0x80)
    13133
                mstore(0x40, 0xc0)
    13134
                mstore(0x60, p2)
    13135
                mstore(0x80, p3)
    13136
                writeString(0xa0, p0)
    13137
                writeString(0xe0, p1)
    13138
            }
    13139
            _sendLogPayload(0x1c, 0x104);
    13140
            /// @solidity memory-safe-assembly
    13141
            assembly {
    13142
                mstore(0x00, m0)
    13143
                mstore(0x20, m1)
    13144
                mstore(0x40, m2)
    13145
                mstore(0x60, m3)
    13146
                mstore(0x80, m4)
    13147
                mstore(0xa0, m5)
    13148
                mstore(0xc0, m6)
    13149
                mstore(0xe0, m7)
    13150
                mstore(0x100, m8)
    13151
            }
    13152
        }
    13153
    
                                                    
                                                
    13154
        function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {
    13155
            bytes32 m0;
    13156
            bytes32 m1;
    13157
            bytes32 m2;
    13158
            bytes32 m3;
    13159
            bytes32 m4;
    13160
            bytes32 m5;
    13161
            bytes32 m6;
    13162
            bytes32 m7;
    13163
            bytes32 m8;
    13164
            /// @solidity memory-safe-assembly
    13165
            assembly {
    13166
                function writeString(pos, w) {
    13167
                    let length := 0
    13168
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13169
                    mstore(pos, length)
    13170
                    let shift := sub(256, shl(3, length))
    13171
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13172
                }
    13173
                m0 := mload(0x00)
    13174
                m1 := mload(0x20)
    13175
                m2 := mload(0x40)
    13176
                m3 := mload(0x60)
    13177
                m4 := mload(0x80)
    13178
                m5 := mload(0xa0)
    13179
                m6 := mload(0xc0)
    13180
                m7 := mload(0xe0)
    13181
                m8 := mload(0x100)
    13182
                // Selector of `log(string,string,address,uint256)`.
    13183
                mstore(0x00, 0x7cc3c607)
    13184
                mstore(0x20, 0x80)
    13185
                mstore(0x40, 0xc0)
    13186
                mstore(0x60, p2)
    13187
                mstore(0x80, p3)
    13188
                writeString(0xa0, p0)
    13189
                writeString(0xe0, p1)
    13190
            }
    13191
            _sendLogPayload(0x1c, 0x104);
    13192
            /// @solidity memory-safe-assembly
    13193
            assembly {
    13194
                mstore(0x00, m0)
    13195
                mstore(0x20, m1)
    13196
                mstore(0x40, m2)
    13197
                mstore(0x60, m3)
    13198
                mstore(0x80, m4)
    13199
                mstore(0xa0, m5)
    13200
                mstore(0xc0, m6)
    13201
                mstore(0xe0, m7)
    13202
                mstore(0x100, m8)
    13203
            }
    13204
        }
    13205
    
                                                    
                                                
    13206
        function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    13207
            bytes32 m0;
    13208
            bytes32 m1;
    13209
            bytes32 m2;
    13210
            bytes32 m3;
    13211
            bytes32 m4;
    13212
            bytes32 m5;
    13213
            bytes32 m6;
    13214
            bytes32 m7;
    13215
            bytes32 m8;
    13216
            bytes32 m9;
    13217
            bytes32 m10;
    13218
            /// @solidity memory-safe-assembly
    13219
            assembly {
    13220
                function writeString(pos, w) {
    13221
                    let length := 0
    13222
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13223
                    mstore(pos, length)
    13224
                    let shift := sub(256, shl(3, length))
    13225
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13226
                }
    13227
                m0 := mload(0x00)
    13228
                m1 := mload(0x20)
    13229
                m2 := mload(0x40)
    13230
                m3 := mload(0x60)
    13231
                m4 := mload(0x80)
    13232
                m5 := mload(0xa0)
    13233
                m6 := mload(0xc0)
    13234
                m7 := mload(0xe0)
    13235
                m8 := mload(0x100)
    13236
                m9 := mload(0x120)
    13237
                m10 := mload(0x140)
    13238
                // Selector of `log(string,string,address,string)`.
    13239
                mstore(0x00, 0xeb1bff80)
    13240
                mstore(0x20, 0x80)
    13241
                mstore(0x40, 0xc0)
    13242
                mstore(0x60, p2)
    13243
                mstore(0x80, 0x100)
    13244
                writeString(0xa0, p0)
    13245
                writeString(0xe0, p1)
    13246
                writeString(0x120, p3)
    13247
            }
    13248
            _sendLogPayload(0x1c, 0x144);
    13249
            /// @solidity memory-safe-assembly
    13250
            assembly {
    13251
                mstore(0x00, m0)
    13252
                mstore(0x20, m1)
    13253
                mstore(0x40, m2)
    13254
                mstore(0x60, m3)
    13255
                mstore(0x80, m4)
    13256
                mstore(0xa0, m5)
    13257
                mstore(0xc0, m6)
    13258
                mstore(0xe0, m7)
    13259
                mstore(0x100, m8)
    13260
                mstore(0x120, m9)
    13261
                mstore(0x140, m10)
    13262
            }
    13263
        }
    13264
    
                                                    
                                                
    13265
        function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {
    13266
            bytes32 m0;
    13267
            bytes32 m1;
    13268
            bytes32 m2;
    13269
            bytes32 m3;
    13270
            bytes32 m4;
    13271
            bytes32 m5;
    13272
            bytes32 m6;
    13273
            bytes32 m7;
    13274
            bytes32 m8;
    13275
            /// @solidity memory-safe-assembly
    13276
            assembly {
    13277
                function writeString(pos, w) {
    13278
                    let length := 0
    13279
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13280
                    mstore(pos, length)
    13281
                    let shift := sub(256, shl(3, length))
    13282
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13283
                }
    13284
                m0 := mload(0x00)
    13285
                m1 := mload(0x20)
    13286
                m2 := mload(0x40)
    13287
                m3 := mload(0x60)
    13288
                m4 := mload(0x80)
    13289
                m5 := mload(0xa0)
    13290
                m6 := mload(0xc0)
    13291
                m7 := mload(0xe0)
    13292
                m8 := mload(0x100)
    13293
                // Selector of `log(string,string,bool,address)`.
    13294
                mstore(0x00, 0xc371c7db)
    13295
                mstore(0x20, 0x80)
    13296
                mstore(0x40, 0xc0)
    13297
                mstore(0x60, p2)
    13298
                mstore(0x80, p3)
    13299
                writeString(0xa0, p0)
    13300
                writeString(0xe0, p1)
    13301
            }
    13302
            _sendLogPayload(0x1c, 0x104);
    13303
            /// @solidity memory-safe-assembly
    13304
            assembly {
    13305
                mstore(0x00, m0)
    13306
                mstore(0x20, m1)
    13307
                mstore(0x40, m2)
    13308
                mstore(0x60, m3)
    13309
                mstore(0x80, m4)
    13310
                mstore(0xa0, m5)
    13311
                mstore(0xc0, m6)
    13312
                mstore(0xe0, m7)
    13313
                mstore(0x100, m8)
    13314
            }
    13315
        }
    13316
    
                                                    
                                                
    13317
        function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {
    13318
            bytes32 m0;
    13319
            bytes32 m1;
    13320
            bytes32 m2;
    13321
            bytes32 m3;
    13322
            bytes32 m4;
    13323
            bytes32 m5;
    13324
            bytes32 m6;
    13325
            bytes32 m7;
    13326
            bytes32 m8;
    13327
            /// @solidity memory-safe-assembly
    13328
            assembly {
    13329
                function writeString(pos, w) {
    13330
                    let length := 0
    13331
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13332
                    mstore(pos, length)
    13333
                    let shift := sub(256, shl(3, length))
    13334
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13335
                }
    13336
                m0 := mload(0x00)
    13337
                m1 := mload(0x20)
    13338
                m2 := mload(0x40)
    13339
                m3 := mload(0x60)
    13340
                m4 := mload(0x80)
    13341
                m5 := mload(0xa0)
    13342
                m6 := mload(0xc0)
    13343
                m7 := mload(0xe0)
    13344
                m8 := mload(0x100)
    13345
                // Selector of `log(string,string,bool,bool)`.
    13346
                mstore(0x00, 0x40785869)
    13347
                mstore(0x20, 0x80)
    13348
                mstore(0x40, 0xc0)
    13349
                mstore(0x60, p2)
    13350
                mstore(0x80, p3)
    13351
                writeString(0xa0, p0)
    13352
                writeString(0xe0, p1)
    13353
            }
    13354
            _sendLogPayload(0x1c, 0x104);
    13355
            /// @solidity memory-safe-assembly
    13356
            assembly {
    13357
                mstore(0x00, m0)
    13358
                mstore(0x20, m1)
    13359
                mstore(0x40, m2)
    13360
                mstore(0x60, m3)
    13361
                mstore(0x80, m4)
    13362
                mstore(0xa0, m5)
    13363
                mstore(0xc0, m6)
    13364
                mstore(0xe0, m7)
    13365
                mstore(0x100, m8)
    13366
            }
    13367
        }
    13368
    
                                                    
                                                
    13369
        function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    13370
            bytes32 m0;
    13371
            bytes32 m1;
    13372
            bytes32 m2;
    13373
            bytes32 m3;
    13374
            bytes32 m4;
    13375
            bytes32 m5;
    13376
            bytes32 m6;
    13377
            bytes32 m7;
    13378
            bytes32 m8;
    13379
            /// @solidity memory-safe-assembly
    13380
            assembly {
    13381
                function writeString(pos, w) {
    13382
                    let length := 0
    13383
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13384
                    mstore(pos, length)
    13385
                    let shift := sub(256, shl(3, length))
    13386
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13387
                }
    13388
                m0 := mload(0x00)
    13389
                m1 := mload(0x20)
    13390
                m2 := mload(0x40)
    13391
                m3 := mload(0x60)
    13392
                m4 := mload(0x80)
    13393
                m5 := mload(0xa0)
    13394
                m6 := mload(0xc0)
    13395
                m7 := mload(0xe0)
    13396
                m8 := mload(0x100)
    13397
                // Selector of `log(string,string,bool,uint256)`.
    13398
                mstore(0x00, 0xd6aefad2)
    13399
                mstore(0x20, 0x80)
    13400
                mstore(0x40, 0xc0)
    13401
                mstore(0x60, p2)
    13402
                mstore(0x80, p3)
    13403
                writeString(0xa0, p0)
    13404
                writeString(0xe0, p1)
    13405
            }
    13406
            _sendLogPayload(0x1c, 0x104);
    13407
            /// @solidity memory-safe-assembly
    13408
            assembly {
    13409
                mstore(0x00, m0)
    13410
                mstore(0x20, m1)
    13411
                mstore(0x40, m2)
    13412
                mstore(0x60, m3)
    13413
                mstore(0x80, m4)
    13414
                mstore(0xa0, m5)
    13415
                mstore(0xc0, m6)
    13416
                mstore(0xe0, m7)
    13417
                mstore(0x100, m8)
    13418
            }
    13419
        }
    13420
    
                                                    
                                                
    13421
        function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    13422
            bytes32 m0;
    13423
            bytes32 m1;
    13424
            bytes32 m2;
    13425
            bytes32 m3;
    13426
            bytes32 m4;
    13427
            bytes32 m5;
    13428
            bytes32 m6;
    13429
            bytes32 m7;
    13430
            bytes32 m8;
    13431
            bytes32 m9;
    13432
            bytes32 m10;
    13433
            /// @solidity memory-safe-assembly
    13434
            assembly {
    13435
                function writeString(pos, w) {
    13436
                    let length := 0
    13437
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13438
                    mstore(pos, length)
    13439
                    let shift := sub(256, shl(3, length))
    13440
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13441
                }
    13442
                m0 := mload(0x00)
    13443
                m1 := mload(0x20)
    13444
                m2 := mload(0x40)
    13445
                m3 := mload(0x60)
    13446
                m4 := mload(0x80)
    13447
                m5 := mload(0xa0)
    13448
                m6 := mload(0xc0)
    13449
                m7 := mload(0xe0)
    13450
                m8 := mload(0x100)
    13451
                m9 := mload(0x120)
    13452
                m10 := mload(0x140)
    13453
                // Selector of `log(string,string,bool,string)`.
    13454
                mstore(0x00, 0x5e84b0ea)
    13455
                mstore(0x20, 0x80)
    13456
                mstore(0x40, 0xc0)
    13457
                mstore(0x60, p2)
    13458
                mstore(0x80, 0x100)
    13459
                writeString(0xa0, p0)
    13460
                writeString(0xe0, p1)
    13461
                writeString(0x120, p3)
    13462
            }
    13463
            _sendLogPayload(0x1c, 0x144);
    13464
            /// @solidity memory-safe-assembly
    13465
            assembly {
    13466
                mstore(0x00, m0)
    13467
                mstore(0x20, m1)
    13468
                mstore(0x40, m2)
    13469
                mstore(0x60, m3)
    13470
                mstore(0x80, m4)
    13471
                mstore(0xa0, m5)
    13472
                mstore(0xc0, m6)
    13473
                mstore(0xe0, m7)
    13474
                mstore(0x100, m8)
    13475
                mstore(0x120, m9)
    13476
                mstore(0x140, m10)
    13477
            }
    13478
        }
    13479
    
                                                    
                                                
    13480
        function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {
    13481
            bytes32 m0;
    13482
            bytes32 m1;
    13483
            bytes32 m2;
    13484
            bytes32 m3;
    13485
            bytes32 m4;
    13486
            bytes32 m5;
    13487
            bytes32 m6;
    13488
            bytes32 m7;
    13489
            bytes32 m8;
    13490
            /// @solidity memory-safe-assembly
    13491
            assembly {
    13492
                function writeString(pos, w) {
    13493
                    let length := 0
    13494
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13495
                    mstore(pos, length)
    13496
                    let shift := sub(256, shl(3, length))
    13497
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13498
                }
    13499
                m0 := mload(0x00)
    13500
                m1 := mload(0x20)
    13501
                m2 := mload(0x40)
    13502
                m3 := mload(0x60)
    13503
                m4 := mload(0x80)
    13504
                m5 := mload(0xa0)
    13505
                m6 := mload(0xc0)
    13506
                m7 := mload(0xe0)
    13507
                m8 := mload(0x100)
    13508
                // Selector of `log(string,string,uint256,address)`.
    13509
                mstore(0x00, 0x1023f7b2)
    13510
                mstore(0x20, 0x80)
    13511
                mstore(0x40, 0xc0)
    13512
                mstore(0x60, p2)
    13513
                mstore(0x80, p3)
    13514
                writeString(0xa0, p0)
    13515
                writeString(0xe0, p1)
    13516
            }
    13517
            _sendLogPayload(0x1c, 0x104);
    13518
            /// @solidity memory-safe-assembly
    13519
            assembly {
    13520
                mstore(0x00, m0)
    13521
                mstore(0x20, m1)
    13522
                mstore(0x40, m2)
    13523
                mstore(0x60, m3)
    13524
                mstore(0x80, m4)
    13525
                mstore(0xa0, m5)
    13526
                mstore(0xc0, m6)
    13527
                mstore(0xe0, m7)
    13528
                mstore(0x100, m8)
    13529
            }
    13530
        }
    13531
    
                                                    
                                                
    13532
        function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    13533
            bytes32 m0;
    13534
            bytes32 m1;
    13535
            bytes32 m2;
    13536
            bytes32 m3;
    13537
            bytes32 m4;
    13538
            bytes32 m5;
    13539
            bytes32 m6;
    13540
            bytes32 m7;
    13541
            bytes32 m8;
    13542
            /// @solidity memory-safe-assembly
    13543
            assembly {
    13544
                function writeString(pos, w) {
    13545
                    let length := 0
    13546
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13547
                    mstore(pos, length)
    13548
                    let shift := sub(256, shl(3, length))
    13549
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13550
                }
    13551
                m0 := mload(0x00)
    13552
                m1 := mload(0x20)
    13553
                m2 := mload(0x40)
    13554
                m3 := mload(0x60)
    13555
                m4 := mload(0x80)
    13556
                m5 := mload(0xa0)
    13557
                m6 := mload(0xc0)
    13558
                m7 := mload(0xe0)
    13559
                m8 := mload(0x100)
    13560
                // Selector of `log(string,string,uint256,bool)`.
    13561
                mstore(0x00, 0xc3a8a654)
    13562
                mstore(0x20, 0x80)
    13563
                mstore(0x40, 0xc0)
    13564
                mstore(0x60, p2)
    13565
                mstore(0x80, p3)
    13566
                writeString(0xa0, p0)
    13567
                writeString(0xe0, p1)
    13568
            }
    13569
            _sendLogPayload(0x1c, 0x104);
    13570
            /// @solidity memory-safe-assembly
    13571
            assembly {
    13572
                mstore(0x00, m0)
    13573
                mstore(0x20, m1)
    13574
                mstore(0x40, m2)
    13575
                mstore(0x60, m3)
    13576
                mstore(0x80, m4)
    13577
                mstore(0xa0, m5)
    13578
                mstore(0xc0, m6)
    13579
                mstore(0xe0, m7)
    13580
                mstore(0x100, m8)
    13581
            }
    13582
        }
    13583
    
                                                    
                                                
    13584
        function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    13585
            bytes32 m0;
    13586
            bytes32 m1;
    13587
            bytes32 m2;
    13588
            bytes32 m3;
    13589
            bytes32 m4;
    13590
            bytes32 m5;
    13591
            bytes32 m6;
    13592
            bytes32 m7;
    13593
            bytes32 m8;
    13594
            /// @solidity memory-safe-assembly
    13595
            assembly {
    13596
                function writeString(pos, w) {
    13597
                    let length := 0
    13598
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13599
                    mstore(pos, length)
    13600
                    let shift := sub(256, shl(3, length))
    13601
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13602
                }
    13603
                m0 := mload(0x00)
    13604
                m1 := mload(0x20)
    13605
                m2 := mload(0x40)
    13606
                m3 := mload(0x60)
    13607
                m4 := mload(0x80)
    13608
                m5 := mload(0xa0)
    13609
                m6 := mload(0xc0)
    13610
                m7 := mload(0xe0)
    13611
                m8 := mload(0x100)
    13612
                // Selector of `log(string,string,uint256,uint256)`.
    13613
                mstore(0x00, 0xf45d7d2c)
    13614
                mstore(0x20, 0x80)
    13615
                mstore(0x40, 0xc0)
    13616
                mstore(0x60, p2)
    13617
                mstore(0x80, p3)
    13618
                writeString(0xa0, p0)
    13619
                writeString(0xe0, p1)
    13620
            }
    13621
            _sendLogPayload(0x1c, 0x104);
    13622
            /// @solidity memory-safe-assembly
    13623
            assembly {
    13624
                mstore(0x00, m0)
    13625
                mstore(0x20, m1)
    13626
                mstore(0x40, m2)
    13627
                mstore(0x60, m3)
    13628
                mstore(0x80, m4)
    13629
                mstore(0xa0, m5)
    13630
                mstore(0xc0, m6)
    13631
                mstore(0xe0, m7)
    13632
                mstore(0x100, m8)
    13633
            }
    13634
        }
    13635
    
                                                    
                                                
    13636
        function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    13637
            bytes32 m0;
    13638
            bytes32 m1;
    13639
            bytes32 m2;
    13640
            bytes32 m3;
    13641
            bytes32 m4;
    13642
            bytes32 m5;
    13643
            bytes32 m6;
    13644
            bytes32 m7;
    13645
            bytes32 m8;
    13646
            bytes32 m9;
    13647
            bytes32 m10;
    13648
            /// @solidity memory-safe-assembly
    13649
            assembly {
    13650
                function writeString(pos, w) {
    13651
                    let length := 0
    13652
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13653
                    mstore(pos, length)
    13654
                    let shift := sub(256, shl(3, length))
    13655
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13656
                }
    13657
                m0 := mload(0x00)
    13658
                m1 := mload(0x20)
    13659
                m2 := mload(0x40)
    13660
                m3 := mload(0x60)
    13661
                m4 := mload(0x80)
    13662
                m5 := mload(0xa0)
    13663
                m6 := mload(0xc0)
    13664
                m7 := mload(0xe0)
    13665
                m8 := mload(0x100)
    13666
                m9 := mload(0x120)
    13667
                m10 := mload(0x140)
    13668
                // Selector of `log(string,string,uint256,string)`.
    13669
                mstore(0x00, 0x5d1a971a)
    13670
                mstore(0x20, 0x80)
    13671
                mstore(0x40, 0xc0)
    13672
                mstore(0x60, p2)
    13673
                mstore(0x80, 0x100)
    13674
                writeString(0xa0, p0)
    13675
                writeString(0xe0, p1)
    13676
                writeString(0x120, p3)
    13677
            }
    13678
            _sendLogPayload(0x1c, 0x144);
    13679
            /// @solidity memory-safe-assembly
    13680
            assembly {
    13681
                mstore(0x00, m0)
    13682
                mstore(0x20, m1)
    13683
                mstore(0x40, m2)
    13684
                mstore(0x60, m3)
    13685
                mstore(0x80, m4)
    13686
                mstore(0xa0, m5)
    13687
                mstore(0xc0, m6)
    13688
                mstore(0xe0, m7)
    13689
                mstore(0x100, m8)
    13690
                mstore(0x120, m9)
    13691
                mstore(0x140, m10)
    13692
            }
    13693
        }
    13694
    
                                                    
                                                
    13695
        function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    13696
            bytes32 m0;
    13697
            bytes32 m1;
    13698
            bytes32 m2;
    13699
            bytes32 m3;
    13700
            bytes32 m4;
    13701
            bytes32 m5;
    13702
            bytes32 m6;
    13703
            bytes32 m7;
    13704
            bytes32 m8;
    13705
            bytes32 m9;
    13706
            bytes32 m10;
    13707
            /// @solidity memory-safe-assembly
    13708
            assembly {
    13709
                function writeString(pos, w) {
    13710
                    let length := 0
    13711
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13712
                    mstore(pos, length)
    13713
                    let shift := sub(256, shl(3, length))
    13714
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13715
                }
    13716
                m0 := mload(0x00)
    13717
                m1 := mload(0x20)
    13718
                m2 := mload(0x40)
    13719
                m3 := mload(0x60)
    13720
                m4 := mload(0x80)
    13721
                m5 := mload(0xa0)
    13722
                m6 := mload(0xc0)
    13723
                m7 := mload(0xe0)
    13724
                m8 := mload(0x100)
    13725
                m9 := mload(0x120)
    13726
                m10 := mload(0x140)
    13727
                // Selector of `log(string,string,string,address)`.
    13728
                mstore(0x00, 0x6d572f44)
    13729
                mstore(0x20, 0x80)
    13730
                mstore(0x40, 0xc0)
    13731
                mstore(0x60, 0x100)
    13732
                mstore(0x80, p3)
    13733
                writeString(0xa0, p0)
    13734
                writeString(0xe0, p1)
    13735
                writeString(0x120, p2)
    13736
            }
    13737
            _sendLogPayload(0x1c, 0x144);
    13738
            /// @solidity memory-safe-assembly
    13739
            assembly {
    13740
                mstore(0x00, m0)
    13741
                mstore(0x20, m1)
    13742
                mstore(0x40, m2)
    13743
                mstore(0x60, m3)
    13744
                mstore(0x80, m4)
    13745
                mstore(0xa0, m5)
    13746
                mstore(0xc0, m6)
    13747
                mstore(0xe0, m7)
    13748
                mstore(0x100, m8)
    13749
                mstore(0x120, m9)
    13750
                mstore(0x140, m10)
    13751
            }
    13752
        }
    13753
    
                                                    
                                                
    13754
        function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    13755
            bytes32 m0;
    13756
            bytes32 m1;
    13757
            bytes32 m2;
    13758
            bytes32 m3;
    13759
            bytes32 m4;
    13760
            bytes32 m5;
    13761
            bytes32 m6;
    13762
            bytes32 m7;
    13763
            bytes32 m8;
    13764
            bytes32 m9;
    13765
            bytes32 m10;
    13766
            /// @solidity memory-safe-assembly
    13767
            assembly {
    13768
                function writeString(pos, w) {
    13769
                    let length := 0
    13770
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13771
                    mstore(pos, length)
    13772
                    let shift := sub(256, shl(3, length))
    13773
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13774
                }
    13775
                m0 := mload(0x00)
    13776
                m1 := mload(0x20)
    13777
                m2 := mload(0x40)
    13778
                m3 := mload(0x60)
    13779
                m4 := mload(0x80)
    13780
                m5 := mload(0xa0)
    13781
                m6 := mload(0xc0)
    13782
                m7 := mload(0xe0)
    13783
                m8 := mload(0x100)
    13784
                m9 := mload(0x120)
    13785
                m10 := mload(0x140)
    13786
                // Selector of `log(string,string,string,bool)`.
    13787
                mstore(0x00, 0x2c1754ed)
    13788
                mstore(0x20, 0x80)
    13789
                mstore(0x40, 0xc0)
    13790
                mstore(0x60, 0x100)
    13791
                mstore(0x80, p3)
    13792
                writeString(0xa0, p0)
    13793
                writeString(0xe0, p1)
    13794
                writeString(0x120, p2)
    13795
            }
    13796
            _sendLogPayload(0x1c, 0x144);
    13797
            /// @solidity memory-safe-assembly
    13798
            assembly {
    13799
                mstore(0x00, m0)
    13800
                mstore(0x20, m1)
    13801
                mstore(0x40, m2)
    13802
                mstore(0x60, m3)
    13803
                mstore(0x80, m4)
    13804
                mstore(0xa0, m5)
    13805
                mstore(0xc0, m6)
    13806
                mstore(0xe0, m7)
    13807
                mstore(0x100, m8)
    13808
                mstore(0x120, m9)
    13809
                mstore(0x140, m10)
    13810
            }
    13811
        }
    13812
    
                                                    
                                                
    13813
        function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    13814
            bytes32 m0;
    13815
            bytes32 m1;
    13816
            bytes32 m2;
    13817
            bytes32 m3;
    13818
            bytes32 m4;
    13819
            bytes32 m5;
    13820
            bytes32 m6;
    13821
            bytes32 m7;
    13822
            bytes32 m8;
    13823
            bytes32 m9;
    13824
            bytes32 m10;
    13825
            /// @solidity memory-safe-assembly
    13826
            assembly {
    13827
                function writeString(pos, w) {
    13828
                    let length := 0
    13829
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13830
                    mstore(pos, length)
    13831
                    let shift := sub(256, shl(3, length))
    13832
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13833
                }
    13834
                m0 := mload(0x00)
    13835
                m1 := mload(0x20)
    13836
                m2 := mload(0x40)
    13837
                m3 := mload(0x60)
    13838
                m4 := mload(0x80)
    13839
                m5 := mload(0xa0)
    13840
                m6 := mload(0xc0)
    13841
                m7 := mload(0xe0)
    13842
                m8 := mload(0x100)
    13843
                m9 := mload(0x120)
    13844
                m10 := mload(0x140)
    13845
                // Selector of `log(string,string,string,uint256)`.
    13846
                mstore(0x00, 0x8eafb02b)
    13847
                mstore(0x20, 0x80)
    13848
                mstore(0x40, 0xc0)
    13849
                mstore(0x60, 0x100)
    13850
                mstore(0x80, p3)
    13851
                writeString(0xa0, p0)
    13852
                writeString(0xe0, p1)
    13853
                writeString(0x120, p2)
    13854
            }
    13855
            _sendLogPayload(0x1c, 0x144);
    13856
            /// @solidity memory-safe-assembly
    13857
            assembly {
    13858
                mstore(0x00, m0)
    13859
                mstore(0x20, m1)
    13860
                mstore(0x40, m2)
    13861
                mstore(0x60, m3)
    13862
                mstore(0x80, m4)
    13863
                mstore(0xa0, m5)
    13864
                mstore(0xc0, m6)
    13865
                mstore(0xe0, m7)
    13866
                mstore(0x100, m8)
    13867
                mstore(0x120, m9)
    13868
                mstore(0x140, m10)
    13869
            }
    13870
        }
    13871
    
                                                    
                                                
    13872
        function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    13873
            bytes32 m0;
    13874
            bytes32 m1;
    13875
            bytes32 m2;
    13876
            bytes32 m3;
    13877
            bytes32 m4;
    13878
            bytes32 m5;
    13879
            bytes32 m6;
    13880
            bytes32 m7;
    13881
            bytes32 m8;
    13882
            bytes32 m9;
    13883
            bytes32 m10;
    13884
            bytes32 m11;
    13885
            bytes32 m12;
    13886
            /// @solidity memory-safe-assembly
    13887
            assembly {
    13888
                function writeString(pos, w) {
    13889
                    let length := 0
    13890
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13891
                    mstore(pos, length)
    13892
                    let shift := sub(256, shl(3, length))
    13893
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13894
                }
    13895
                m0 := mload(0x00)
    13896
                m1 := mload(0x20)
    13897
                m2 := mload(0x40)
    13898
                m3 := mload(0x60)
    13899
                m4 := mload(0x80)
    13900
                m5 := mload(0xa0)
    13901
                m6 := mload(0xc0)
    13902
                m7 := mload(0xe0)
    13903
                m8 := mload(0x100)
    13904
                m9 := mload(0x120)
    13905
                m10 := mload(0x140)
    13906
                m11 := mload(0x160)
    13907
                m12 := mload(0x180)
    13908
                // Selector of `log(string,string,string,string)`.
    13909
                mstore(0x00, 0xde68f20a)
    13910
                mstore(0x20, 0x80)
    13911
                mstore(0x40, 0xc0)
    13912
                mstore(0x60, 0x100)
    13913
                mstore(0x80, 0x140)
    13914
                writeString(0xa0, p0)
    13915
                writeString(0xe0, p1)
    13916
                writeString(0x120, p2)
    13917
                writeString(0x160, p3)
    13918
            }
    13919
            _sendLogPayload(0x1c, 0x184);
    13920
            /// @solidity memory-safe-assembly
    13921
            assembly {
    13922
                mstore(0x00, m0)
    13923
                mstore(0x20, m1)
    13924
                mstore(0x40, m2)
    13925
                mstore(0x60, m3)
    13926
                mstore(0x80, m4)
    13927
                mstore(0xa0, m5)
    13928
                mstore(0xc0, m6)
    13929
                mstore(0xe0, m7)
    13930
                mstore(0x100, m8)
    13931
                mstore(0x120, m9)
    13932
                mstore(0x140, m10)
    13933
                mstore(0x160, m11)
    13934
                mstore(0x180, m12)
    13935
            }
    13936
        }
    13937
    }
    13938
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
    3
    pragma solidity ^0.8.20;
    4
    
                                                    
                                                
    5
    /**
    6
     * @dev Standard ERC20 Errors
    7
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
    8
     */
    9
    interface IERC20Errors {
    10
        /**
    11
         * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
    12
         * @param sender Address whose tokens are being transferred.
    13
         * @param balance Current balance for the interacting account.
    14
         * @param needed Minimum amount required to perform a transfer.
    15
         */
    16
        error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
    17
    
                                                    
                                                
    18
        /**
    19
         * @dev Indicates a failure with the token `sender`. Used in transfers.
    20
         * @param sender Address whose tokens are being transferred.
    21
         */
    22
        error ERC20InvalidSender(address sender);
    23
    
                                                    
                                                
    24
        /**
    25
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
    26
         * @param receiver Address to which tokens are being transferred.
    27
         */
    28
        error ERC20InvalidReceiver(address receiver);
    29
    
                                                    
                                                
    30
        /**
    31
         * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
    32
         * @param spender Address that may be allowed to operate on tokens without being their owner.
    33
         * @param allowance Amount of tokens a `spender` is allowed to operate with.
    34
         * @param needed Minimum amount required to perform a transfer.
    35
         */
    36
        error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
    37
    
                                                    
                                                
    38
        /**
    39
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
    40
         * @param approver Address initiating an approval operation.
    41
         */
    42
        error ERC20InvalidApprover(address approver);
    43
    
                                                    
                                                
    44
        /**
    45
         * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
    46
         * @param spender Address that may be allowed to operate on tokens without being their owner.
    47
         */
    48
        error ERC20InvalidSpender(address spender);
    49
    }
    50
    
                                                    
                                                
    51
    /**
    52
     * @dev Standard ERC721 Errors
    53
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
    54
     */
    55
    interface IERC721Errors {
    56
        /**
    57
         * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
    58
         * Used in balance queries.
    59
         * @param owner Address of the current owner of a token.
    60
         */
    61
        error ERC721InvalidOwner(address owner);
    62
    
                                                    
                                                
    63
        /**
    64
         * @dev Indicates a `tokenId` whose `owner` is the zero address.
    65
         * @param tokenId Identifier number of a token.
    66
         */
    67
        error ERC721NonexistentToken(uint256 tokenId);
    68
    
                                                    
                                                
    69
        /**
    70
         * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
    71
         * @param sender Address whose tokens are being transferred.
    72
         * @param tokenId Identifier number of a token.
    73
         * @param owner Address of the current owner of a token.
    74
         */
    75
        error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
    76
    
                                                    
                                                
    77
        /**
    78
         * @dev Indicates a failure with the token `sender`. Used in transfers.
    79
         * @param sender Address whose tokens are being transferred.
    80
         */
    81
        error ERC721InvalidSender(address sender);
    82
    
                                                    
                                                
    83
        /**
    84
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
    85
         * @param receiver Address to which tokens are being transferred.
    86
         */
    87
        error ERC721InvalidReceiver(address receiver);
    88
    
                                                    
                                                
    89
        /**
    90
         * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
    91
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    92
         * @param tokenId Identifier number of a token.
    93
         */
    94
        error ERC721InsufficientApproval(address operator, uint256 tokenId);
    95
    
                                                    
                                                
    96
        /**
    97
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
    98
         * @param approver Address initiating an approval operation.
    99
         */
    100
        error ERC721InvalidApprover(address approver);
    101
    
                                                    
                                                
    102
        /**
    103
         * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
    104
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    105
         */
    106
        error ERC721InvalidOperator(address operator);
    107
    }
    108
    
                                                    
                                                
    109
    /**
    110
     * @dev Standard ERC1155 Errors
    111
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
    112
     */
    113
    interface IERC1155Errors {
    114
        /**
    115
         * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
    116
         * @param sender Address whose tokens are being transferred.
    117
         * @param balance Current balance for the interacting account.
    118
         * @param needed Minimum amount required to perform a transfer.
    119
         * @param tokenId Identifier number of a token.
    120
         */
    121
        error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
    122
    
                                                    
                                                
    123
        /**
    124
         * @dev Indicates a failure with the token `sender`. Used in transfers.
    125
         * @param sender Address whose tokens are being transferred.
    126
         */
    127
        error ERC1155InvalidSender(address sender);
    128
    
                                                    
                                                
    129
        /**
    130
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
    131
         * @param receiver Address to which tokens are being transferred.
    132
         */
    133
        error ERC1155InvalidReceiver(address receiver);
    134
    
                                                    
                                                
    135
        /**
    136
         * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
    137
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    138
         * @param owner Address of the current owner of a token.
    139
         */
    140
        error ERC1155MissingApprovalForAll(address operator, address owner);
    141
    
                                                    
                                                
    142
        /**
    143
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
    144
         * @param approver Address initiating an approval operation.
    145
         */
    146
        error ERC1155InvalidApprover(address approver);
    147
    
                                                    
                                                
    148
        /**
    149
         * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
    150
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    151
         */
    152
        error ERC1155InvalidOperator(address operator);
    153
    
                                                    
                                                
    154
        /**
    155
         * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
    156
         * Used in batch transfers.
    157
         * @param idsLength Length of the array of token identifiers
    158
         * @param valuesLength Length of the array of token amounts
    159
         */
    160
        error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
    161
    }
    162
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/mocks/token/ERC20Mock.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.20;
    3
    
                                                    
                                                
    4
    import {ERC20} from "../../token/ERC20/ERC20.sol";
    5
    
                                                    
                                                
    6
    contract ERC20Mock is ERC20 {
    7
        constructor() ERC20("ERC20Mock", "E20M") {}
    8
    
                                                    
                                                
    9
        function mint(address account, uint256 amount) external {
    10
            _mint(account, amount);
    11
        }
    12
    
                                                    
                                                
    13
        function burn(address account, uint256 amount) external {
    14
            _burn(account, amount);
    15
        }
    16
    }
    17
    
                                                    
                                                
    34.6% lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol
    Lines covered: 9 / 26 (34.6%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    import {IERC20} from "./IERC20.sol";
    7
    import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
    8
    import {Context} from "../../utils/Context.sol";
    9
    import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";
    10
    
                                                    
                                                
    11
    /**
    12
     * @dev Implementation of the {IERC20} interface.
    13
     *
    14
     * This implementation is agnostic to the way tokens are created. This means
    15
     * that a supply mechanism has to be added in a derived contract using {_mint}.
    16
     *
    17
     * TIP: For a detailed writeup see our guide
    18
     * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
    19
     * to implement supply mechanisms].
    20
     *
    21
     * The default value of {decimals} is 18. To change this, you should override
    22
     * this function so it returns a different value.
    23
     *
    24
     * We have followed general OpenZeppelin Contracts guidelines: functions revert
    25
     * instead returning `false` on failure. This behavior is nonetheless
    26
     * conventional and does not conflict with the expectations of ERC20
    27
     * applications.
    28
     *
    29
     * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
    30
     * This allows applications to reconstruct the allowance for all accounts just
    31
     * by listening to said events. Other implementations of the EIP may not emit
    32
     * these events, as it isn't required by the specification.
    33
     */
    34
    abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    35
        mapping(address account => uint256) private _balances;
    36
    
                                                    
                                                
    37
        mapping(address account => mapping(address spender => uint256)) private _allowances;
    38
    
                                                    
                                                
    39
        uint256 private _totalSupply;
    40
    
                                                    
                                                
    41
        string private _name;
    42
        string private _symbol;
    43
    
                                                    
                                                
    44
        /**
    45
         * @dev Sets the values for {name} and {symbol}.
    46
         *
    47
         * All two of these values are immutable: they can only be set once during
    48
         * construction.
    49
         */
    50
        constructor(string memory name_, string memory symbol_) {
    51
    ✓ 1
            _name = name_;
    52
    ✓ 1
            _symbol = symbol_;
    53
        }
    54
    
                                                    
                                                
    55
        /**
    56
         * @dev Returns the name of the token.
    57
         */
    58
        function name() public view virtual returns (string memory) {
    59
            return _name;
    60
        }
    61
    
                                                    
                                                
    62
        /**
    63
         * @dev Returns the symbol of the token, usually a shorter version of the
    64
         * name.
    65
         */
    66
        function symbol() public view virtual returns (string memory) {
    67
            return _symbol;
    68
        }
    69
    
                                                    
                                                
    70
        /**
    71
         * @dev Returns the number of decimals used to get its user representation.
    72
         * For example, if `decimals` equals `2`, a balance of `505` tokens should
    73
         * be displayed to a user as `5.05` (`505 / 10 ** 2`).
    74
         *
    75
         * Tokens usually opt for a value of 18, imitating the relationship between
    76
         * Ether and Wei. This is the default value returned by this function, unless
    77
         * it's overridden.
    78
         *
    79
         * NOTE: This information is only used for _display_ purposes: it in
    80
         * no way affects any of the arithmetic of the contract, including
    81
         * {IERC20-balanceOf} and {IERC20-transfer}.
    82
         */
    83
        function decimals() public view virtual returns (uint8) {
    84
            return 18;
    85
        }
    86
    
                                                    
                                                
    87
        /**
    88
         * @dev See {IERC20-totalSupply}.
    89
         */
    90
        function totalSupply() public view virtual returns (uint256) {
    91
            return _totalSupply;
    92
        }
    93
    
                                                    
                                                
    94
        /**
    95
         * @dev See {IERC20-balanceOf}.
    96
         */
    97
        function balanceOf(address account) public view virtual returns (uint256) {
    98
            return _balances[account];
    99
        }
    100
    
                                                    
                                                
    101
        /**
    102
         * @dev See {IERC20-transfer}.
    103
         *
    104
         * Requirements:
    105
         *
    106
         * - `to` cannot be the zero address.
    107
         * - the caller must have a balance of at least `value`.
    108
         */
    109
        function transfer(address to, uint256 value) public virtual returns (bool) {
    110
            address owner = _msgSender();
    111
            _transfer(owner, to, value);
    112
            return true;
    113
        }
    114
    
                                                    
                                                
    115
        /**
    116
         * @dev See {IERC20-allowance}.
    117
         */
    118
        function allowance(address owner, address spender) public view virtual returns (uint256) {
    119
            return _allowances[owner][spender];
    120
        }
    121
    
                                                    
                                                
    122
        /**
    123
         * @dev See {IERC20-approve}.
    124
         *
    125
         * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
    126
         * `transferFrom`. This is semantically equivalent to an infinite approval.
    127
         *
    128
         * Requirements:
    129
         *
    130
         * - `spender` cannot be the zero address.
    131
         */
    132
        function approve(address spender, uint256 value) public virtual returns (bool) {
    133
            address owner = _msgSender();
    134
            _approve(owner, spender, value);
    135
            return true;
    136
        }
    137
    
                                                    
                                                
    138
        /**
    139
         * @dev See {IERC20-transferFrom}.
    140
         *
    141
         * Emits an {Approval} event indicating the updated allowance. This is not
    142
         * required by the EIP. See the note at the beginning of {ERC20}.
    143
         *
    144
         * NOTE: Does not update the allowance if the current allowance
    145
         * is the maximum `uint256`.
    146
         *
    147
         * Requirements:
    148
         *
    149
         * - `from` and `to` cannot be the zero address.
    150
         * - `from` must have a balance of at least `value`.
    151
         * - the caller must have allowance for ``from``'s tokens of at least
    152
         * `value`.
    153
         */
    154
        function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
    155
            address spender = _msgSender();
    156
            _spendAllowance(from, spender, value);
    157
            _transfer(from, to, value);
    158
            return true;
    159
        }
    160
    
                                                    
                                                
    161
        /**
    162
         * @dev Moves a `value` amount of tokens from `from` to `to`.
    163
         *
    164
         * This internal function is equivalent to {transfer}, and can be used to
    165
         * e.g. implement automatic token fees, slashing mechanisms, etc.
    166
         *
    167
         * Emits a {Transfer} event.
    168
         *
    169
         * NOTE: This function is not virtual, {_update} should be overridden instead.
    170
         */
    171
        function _transfer(address from, address to, uint256 value) internal {
    172
            if (from == address(0)) {
    173
                revert ERC20InvalidSender(address(0));
    174
            }
    175
            if (to == address(0)) {
    176
                revert ERC20InvalidReceiver(address(0));
    177
            }
    178
            _update(from, to, value);
    179
        }
    180
    
                                                    
                                                
    181
        /**
    182
         * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
    183
         * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
    184
         * this function.
    185
         *
    186
         * Emits a {Transfer} event.
    187
         */
    188
        function _update(address from, address to, uint256 value) internal virtual {
    189
            if (from == address(0)) {
    190
                // Overflow check required: The rest of the code assumes that totalSupply never overflows
    191
    ✓ 762
                _totalSupply += value;
    192
            } else {
    193
                uint256 fromBalance = _balances[from];
    194
    ✓ 78
                if (fromBalance < value) {
    195
    ✓ 3
    ⟲ 3
                    revert ERC20InsufficientBalance(from, fromBalance, value);
    196
                }
    197
                unchecked {
    198
                    // Overflow not possible: value <= fromBalance <= totalSupply.
    199
                    _balances[from] = fromBalance - value;
    200
                }
    201
            }
    202
    
                                                    
                                                
    203
            if (to == address(0)) {
    204
                unchecked {
    205
                    // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
    206
    ✓ 75
                    _totalSupply -= value;
    207
                }
    208
            } else {
    209
                unchecked {
    210
                    // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
    211
                    _balances[to] += value;
    212
                }
    213
            }
    214
    
                                                    
                                                
    215
    ✓ 744
            emit Transfer(from, to, value);
    216
        }
    217
    
                                                    
                                                
    218
        /**
    219
         * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
    220
         * Relies on the `_update` mechanism
    221
         *
    222
         * Emits a {Transfer} event with `from` set to the zero address.
    223
         *
    224
         * NOTE: This function is not virtual, {_update} should be overridden instead.
    225
         */
    226
        function _mint(address account, uint256 value) internal {
    227
    ✓ 762
            if (account == address(0)) {
    228
                revert ERC20InvalidReceiver(address(0));
    229
            }
    230
            _update(address(0), account, value);
    231
        }
    232
    
                                                    
                                                
    233
        /**
    234
         * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
    235
         * Relies on the `_update` mechanism.
    236
         *
    237
         * Emits a {Transfer} event with `to` set to the zero address.
    238
         *
    239
         * NOTE: This function is not virtual, {_update} should be overridden instead
    240
         */
    241
        function _burn(address account, uint256 value) internal {
    242
    ✓ 78
            if (account == address(0)) {
    243
                revert ERC20InvalidSender(address(0));
    244
            }
    245
            _update(account, address(0), value);
    246
        }
    247
    
                                                    
                                                
    248
        /**
    249
         * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
    250
         *
    251
         * This internal function is equivalent to `approve`, and can be used to
    252
         * e.g. set automatic allowances for certain subsystems, etc.
    253
         *
    254
         * Emits an {Approval} event.
    255
         *
    256
         * Requirements:
    257
         *
    258
         * - `owner` cannot be the zero address.
    259
         * - `spender` cannot be the zero address.
    260
         *
    261
         * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
    262
         */
    263
        function _approve(address owner, address spender, uint256 value) internal {
    264
            _approve(owner, spender, value, true);
    265
        }
    266
    
                                                    
                                                
    267
        /**
    268
         * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
    269
         *
    270
         * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
    271
         * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
    272
         * `Approval` event during `transferFrom` operations.
    273
         *
    274
         * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
    275
         * true using the following override:
    276
         * ```
    277
         * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
    278
         *     super._approve(owner, spender, value, true);
    279
         * }
    280
         * ```
    281
         *
    282
         * Requirements are the same as {_approve}.
    283
         */
    284
        function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
    285
            if (owner == address(0)) {
    286
                revert ERC20InvalidApprover(address(0));
    287
            }
    288
            if (spender == address(0)) {
    289
                revert ERC20InvalidSpender(address(0));
    290
            }
    291
            _allowances[owner][spender] = value;
    292
            if (emitEvent) {
    293
                emit Approval(owner, spender, value);
    294
            }
    295
        }
    296
    
                                                    
                                                
    297
        /**
    298
         * @dev Updates `owner` s allowance for `spender` based on spent `value`.
    299
         *
    300
         * Does not update the allowance value in case of infinite allowance.
    301
         * Revert if not enough allowance is available.
    302
         *
    303
         * Does not emit an {Approval} event.
    304
         */
    305
        function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
    306
            uint256 currentAllowance = allowance(owner, spender);
    307
            if (currentAllowance != type(uint256).max) {
    308
                if (currentAllowance < value) {
    309
                    revert ERC20InsufficientAllowance(spender, currentAllowance, value);
    310
                }
    311
                unchecked {
    312
                    _approve(owner, spender, currentAllowance - value, false);
    313
                }
    314
            }
    315
        }
    316
    }
    317
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    /**
    7
     * @dev Interface of the ERC20 standard as defined in the EIP.
    8
     */
    9
    interface IERC20 {
    10
        /**
    11
         * @dev Emitted when `value` tokens are moved from one account (`from`) to
    12
         * another (`to`).
    13
         *
    14
         * Note that `value` may be zero.
    15
         */
    16
        event Transfer(address indexed from, address indexed to, uint256 value);
    17
    
                                                    
                                                
    18
        /**
    19
         * @dev Emitted when the allowance of a `spender` for an `owner` is set by
    20
         * a call to {approve}. `value` is the new allowance.
    21
         */
    22
        event Approval(address indexed owner, address indexed spender, uint256 value);
    23
    
                                                    
                                                
    24
        /**
    25
         * @dev Returns the value of tokens in existence.
    26
         */
    27
        function totalSupply() external view returns (uint256);
    28
    
                                                    
                                                
    29
        /**
    30
         * @dev Returns the value of tokens owned by `account`.
    31
         */
    32
        function balanceOf(address account) external view returns (uint256);
    33
    
                                                    
                                                
    34
        /**
    35
         * @dev Moves a `value` amount of tokens from the caller's account to `to`.
    36
         *
    37
         * Returns a boolean value indicating whether the operation succeeded.
    38
         *
    39
         * Emits a {Transfer} event.
    40
         */
    41
        function transfer(address to, uint256 value) external returns (bool);
    42
    
                                                    
                                                
    43
        /**
    44
         * @dev Returns the remaining number of tokens that `spender` will be
    45
         * allowed to spend on behalf of `owner` through {transferFrom}. This is
    46
         * zero by default.
    47
         *
    48
         * This value changes when {approve} or {transferFrom} are called.
    49
         */
    50
        function allowance(address owner, address spender) external view returns (uint256);
    51
    
                                                    
                                                
    52
        /**
    53
         * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
    54
         * caller's tokens.
    55
         *
    56
         * Returns a boolean value indicating whether the operation succeeded.
    57
         *
    58
         * IMPORTANT: Beware that changing an allowance with this method brings the risk
    59
         * that someone may use both the old and the new allowance by unfortunate
    60
         * transaction ordering. One possible solution to mitigate this race
    61
         * condition is to first reduce the spender's allowance to 0 and set the
    62
         * desired value afterwards:
    63
         * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    64
         *
    65
         * Emits an {Approval} event.
    66
         */
    67
        function approve(address spender, uint256 value) external returns (bool);
    68
    
                                                    
                                                
    69
        /**
    70
         * @dev Moves a `value` amount of tokens from `from` to `to` using the
    71
         * allowance mechanism. `value` is then deducted from the caller's
    72
         * allowance.
    73
         *
    74
         * Returns a boolean value indicating whether the operation succeeded.
    75
         *
    76
         * Emits a {Transfer} event.
    77
         */
    78
        function transferFrom(address from, address to, uint256 value) external returns (bool);
    79
    }
    80
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    import {IERC20} from "../IERC20.sol";
    7
    
                                                    
                                                
    8
    /**
    9
     * @dev Interface for the optional metadata functions from the ERC20 standard.
    10
     */
    11
    interface IERC20Metadata is IERC20 {
    12
        /**
    13
         * @dev Returns the name of the token.
    14
         */
    15
        function name() external view returns (string memory);
    16
    
                                                    
                                                
    17
        /**
    18
         * @dev Returns the symbol of the token.
    19
         */
    20
        function symbol() external view returns (string memory);
    21
    
                                                    
                                                
    22
        /**
    23
         * @dev Returns the decimals places of the token.
    24
         */
    25
        function decimals() external view returns (uint8);
    26
    }
    27
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    /**
    7
     * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
    8
     * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
    9
     *
    10
     * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
    11
     * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
    12
     * need to send a transaction, and thus is not required to hold Ether at all.
    13
     *
    14
     * ==== Security Considerations
    15
     *
    16
     * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
    17
     * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
    18
     * considered as an intention to spend the allowance in any specific way. The second is that because permits have
    19
     * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
    20
     * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
    21
     * generally recommended is:
    22
     *
    23
     * ```solidity
    24
     * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
    25
     *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
    26
     *     doThing(..., value);
    27
     * }
    28
     *
    29
     * function doThing(..., uint256 value) public {
    30
     *     token.safeTransferFrom(msg.sender, address(this), value);
    31
     *     ...
    32
     * }
    33
     * ```
    34
     *
    35
     * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
    36
     * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
    37
     * {SafeERC20-safeTransferFrom}).
    38
     *
    39
     * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
    40
     * contracts should have entry points that don't rely on permit.
    41
     */
    42
    interface IERC20Permit {
    43
        /**
    44
         * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
    45
         * given ``owner``'s signed approval.
    46
         *
    47
         * IMPORTANT: The same issues {IERC20-approve} has related to transaction
    48
         * ordering also apply here.
    49
         *
    50
         * Emits an {Approval} event.
    51
         *
    52
         * Requirements:
    53
         *
    54
         * - `spender` cannot be the zero address.
    55
         * - `deadline` must be a timestamp in the future.
    56
         * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
    57
         * over the EIP712-formatted function arguments.
    58
         * - the signature must use ``owner``'s current nonce (see {nonces}).
    59
         *
    60
         * For more information on the signature format, see the
    61
         * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
    62
         * section].
    63
         *
    64
         * CAUTION: See Security Considerations above.
    65
         */
    66
        function permit(
    67
            address owner,
    68
            address spender,
    69
            uint256 value,
    70
            uint256 deadline,
    71
            uint8 v,
    72
            bytes32 r,
    73
            bytes32 s
    74
        ) external;
    75
    
                                                    
                                                
    76
        /**
    77
         * @dev Returns the current nonce for `owner`. This value must be
    78
         * included whenever a signature is generated for {permit}.
    79
         *
    80
         * Every successful call to {permit} increases ``owner``'s nonce by one. This
    81
         * prevents a signature from being used multiple times.
    82
         */
    83
        function nonces(address owner) external view returns (uint256);
    84
    
                                                    
                                                
    85
        /**
    86
         * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
    87
         */
    88
        // solhint-disable-next-line func-name-mixedcase
    89
        function DOMAIN_SEPARATOR() external view returns (bytes32);
    90
    }
    91
    
                                                    
                                                
    80.0% lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol
    Lines covered: 4 / 5 (80.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    import {IERC20} from "../IERC20.sol";
    7
    import {IERC20Permit} from "../extensions/IERC20Permit.sol";
    8
    import {Address} from "../../../utils/Address.sol";
    9
    
                                                    
                                                
    10
    /**
    11
     * @title SafeERC20
    12
     * @dev Wrappers around ERC20 operations that throw on failure (when the token
    13
     * contract returns false). Tokens that return no value (and instead revert or
    14
     * throw on failure) are also supported, non-reverting calls are assumed to be
    15
     * successful.
    16
     * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
    17
     * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
    18
     */
    19
    ✓ 13
    library SafeERC20 {
    20
        using Address for address;
    21
    
                                                    
                                                
    22
        /**
    23
         * @dev An operation with an ERC20 token failed.
    24
         */
    25
        error SafeERC20FailedOperation(address token);
    26
    
                                                    
                                                
    27
        /**
    28
         * @dev Indicates a failed `decreaseAllowance` request.
    29
         */
    30
        error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
    31
    
                                                    
                                                
    32
        /**
    33
         * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
    34
         * non-reverting calls are assumed to be successful.
    35
         */
    36
        function safeTransfer(IERC20 token, address to, uint256 value) internal {
    37
    ✓ 14.9K
            _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    38
        }
    39
    
                                                    
                                                
    40
        /**
    41
         * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
    42
         * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
    43
         */
    44
        function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
    45
    ✓ 1.4K
            _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    46
        }
    47
    
                                                    
                                                
    48
        /**
    49
         * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
    50
         * non-reverting calls are assumed to be successful.
    51
         */
    52
        function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
    53
            uint256 oldAllowance = token.allowance(address(this), spender);
    54
            forceApprove(token, spender, oldAllowance + value);
    55
        }
    56
    
                                                    
                                                
    57
        /**
    58
         * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
    59
         * value, non-reverting calls are assumed to be successful.
    60
         */
    61
        function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
    62
            unchecked {
    63
                uint256 currentAllowance = token.allowance(address(this), spender);
    64
                if (currentAllowance < requestedDecrease) {
    65
                    revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
    66
                }
    67
                forceApprove(token, spender, currentAllowance - requestedDecrease);
    68
            }
    69
        }
    70
    
                                                    
                                                
    71
        /**
    72
         * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
    73
         * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
    74
         * to be set to zero before setting it to a non-zero value, such as USDT.
    75
         */
    76
        function forceApprove(IERC20 token, address spender, uint256 value) internal {
    77
            bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
    78
    
                                                    
                                                
    79
            if (!_callOptionalReturnBool(token, approvalCall)) {
    80
                _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
    81
                _callOptionalReturn(token, approvalCall);
    82
            }
    83
        }
    84
    
                                                    
                                                
    85
        /**
    86
         * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
    87
         * on the return value: the return value is optional (but if data is returned, it must not be false).
    88
         * @param token The token targeted by the call.
    89
         * @param data The call data (encoded using abi.encode or one of its variants).
    90
         */
    91
        function _callOptionalReturn(IERC20 token, bytes memory data) private {
    92
            // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
    93
            // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
    94
            // the target address contains contract code and also asserts for success in the low-level call.
    95
    
                                                    
                                                
    96
            bytes memory returndata = address(token).functionCall(data);
    97
    ✓ 2.0K
            if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
    98
                revert SafeERC20FailedOperation(address(token));
    99
            }
    100
        }
    101
    
                                                    
                                                
    102
        /**
    103
         * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
    104
         * on the return value: the return value is optional (but if data is returned, it must not be false).
    105
         * @param token The token targeted by the call.
    106
         * @param data The call data (encoded using abi.encode or one of its variants).
    107
         *
    108
         * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
    109
         */
    110
        function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
    111
            // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
    112
            // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
    113
            // and not revert is the subcall reverts.
    114
    
                                                    
                                                
    115
            (bool success, bytes memory returndata) = address(token).call(data);
    116
            return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    117
        }
    118
    }
    119
    
                                                    
                                                
    54.5% lib/openzeppelin-contracts/contracts/utils/Address.sol
    Lines covered: 6 / 11 (54.5%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    /**
    7
     * @dev Collection of functions related to the address type
    8
     */
    9
    ✓ 13
    library Address {
    10
        /**
    11
         * @dev The ETH balance of the account is not enough to perform the operation.
    12
         */
    13
        error AddressInsufficientBalance(address account);
    14
    
                                                    
                                                
    15
        /**
    16
         * @dev There's no code at `target` (it is not a contract).
    17
         */
    18
        error AddressEmptyCode(address target);
    19
    
                                                    
                                                
    20
        /**
    21
         * @dev A call to an address target failed. The target may have reverted.
    22
         */
    23
        error FailedInnerCall();
    24
    
                                                    
                                                
    25
        /**
    26
         * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
    27
         * `recipient`, forwarding all available gas and reverting on errors.
    28
         *
    29
         * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
    30
         * of certain opcodes, possibly making contracts go over the 2300 gas limit
    31
         * imposed by `transfer`, making them unable to receive funds via
    32
         * `transfer`. {sendValue} removes this limitation.
    33
         *
    34
         * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
    35
         *
    36
         * IMPORTANT: because control is transferred to `recipient`, care must be
    37
         * taken to not create reentrancy vulnerabilities. Consider using
    38
         * {ReentrancyGuard} or the
    39
         * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
    40
         */
    41
        function sendValue(address payable recipient, uint256 amount) internal {
    42
            if (address(this).balance < amount) {
    43
                revert AddressInsufficientBalance(address(this));
    44
            }
    45
    
                                                    
                                                
    46
            (bool success, ) = recipient.call{value: amount}("");
    47
            if (!success) {
    48
                revert FailedInnerCall();
    49
            }
    50
        }
    51
    
                                                    
                                                
    52
        /**
    53
         * @dev Performs a Solidity function call using a low level `call`. A
    54
         * plain `call` is an unsafe replacement for a function call: use this
    55
         * function instead.
    56
         *
    57
         * If `target` reverts with a revert reason or custom error, it is bubbled
    58
         * up by this function (like regular Solidity function calls). However, if
    59
         * the call reverted with no returned reason, this function reverts with a
    60
         * {FailedInnerCall} error.
    61
         *
    62
         * Returns the raw returned data. To convert to the expected return value,
    63
         * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
    64
         *
    65
         * Requirements:
    66
         *
    67
         * - `target` must be a contract.
    68
         * - calling `target` with `data` must not revert.
    69
         */
    70
        function functionCall(address target, bytes memory data) internal returns (bytes memory) {
    71
    ✓ 2.0K
            return functionCallWithValue(target, data, 0);
    72
        }
    73
    
                                                    
                                                
    74
        /**
    75
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
    76
         * but also transferring `value` wei to `target`.
    77
         *
    78
         * Requirements:
    79
         *
    80
         * - the calling contract must have an ETH balance of at least `value`.
    81
         * - the called Solidity function must be `payable`.
    82
         */
    83
        function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
    84
            if (address(this).balance < value) {
    85
                revert AddressInsufficientBalance(address(this));
    86
            }
    87
    ✓ 2.0K
            (bool success, bytes memory returndata) = target.call{value: value}(data);
    88
    ✓ 2.0K
            return verifyCallResultFromTarget(target, success, returndata);
    89
        }
    90
    
                                                    
                                                
    91
        /**
    92
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
    93
         * but performing a static call.
    94
         */
    95
        function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
    96
            (bool success, bytes memory returndata) = target.staticcall(data);
    97
            return verifyCallResultFromTarget(target, success, returndata);
    98
        }
    99
    
                                                    
                                                
    100
        /**
    101
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
    102
         * but performing a delegate call.
    103
         */
    104
        function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
    105
            (bool success, bytes memory returndata) = target.delegatecall(data);
    106
            return verifyCallResultFromTarget(target, success, returndata);
    107
        }
    108
    
                                                    
                                                
    109
        /**
    110
         * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
    111
         * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
    112
         * unsuccessful call.
    113
         */
    114
        function verifyCallResultFromTarget(
    115
            address target,
    116
            bool success,
    117
            bytes memory returndata
    118
        ) internal view returns (bytes memory) {
    119
    ✓ 2.0K
            if (!success) {
    120
                _revert(returndata);
    121
            } else {
    122
                // only check if target is a contract if the call was successful and the return data is empty
    123
                // otherwise we already know that it was a contract
    124
                if (returndata.length == 0 && target.code.length == 0) {
    125
                    revert AddressEmptyCode(target);
    126
                }
    127
    ✓ 2.0K
                return returndata;
    128
            }
    129
        }
    130
    
                                                    
                                                
    131
        /**
    132
         * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
    133
         * revert reason or with a default {FailedInnerCall} error.
    134
         */
    135
        function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
    136
            if (!success) {
    137
                _revert(returndata);
    138
            } else {
    139
                return returndata;
    140
            }
    141
        }
    142
    
                                                    
                                                
    143
        /**
    144
         * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
    145
         */
    146
        function _revert(bytes memory returndata) private pure {
    147
            // Look for revert reason and bubble it up if present
    148
            if (returndata.length > 0) {
    149
                // The easiest way to bubble the revert reason is using memory via assembly
    150
                /// @solidity memory-safe-assembly
    151
                assembly {
    152
                    let returndata_size := mload(returndata)
    153
                    revert(add(32, returndata), returndata_size)
    154
                }
    155
            } else {
    156
                revert FailedInnerCall();
    157
            }
    158
        }
    159
    }
    160
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/utils/Context.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    /**
    7
     * @dev Provides information about the current execution context, including the
    8
     * sender of the transaction and its data. While these are generally available
    9
     * via msg.sender and msg.data, they should not be accessed in such a direct
    10
     * manner, since when dealing with meta-transactions the account sending and
    11
     * paying for execution may not be the actual sender (as far as an application
    12
     * is concerned).
    13
     *
    14
     * This contract is only required for intermediate, library-like contracts.
    15
     */
    16
    abstract contract Context {
    17
        function _msgSender() internal view virtual returns (address) {
    18
            return msg.sender;
    19
        }
    20
    
                                                    
                                                
    21
        function _msgData() internal view virtual returns (bytes calldata) {
    22
            return msg.data;
    23
        }
    24
    
                                                    
                                                
    25
        function _contextSuffixLength() internal view virtual returns (uint256) {
    26
            return 0;
    27
        }
    28
    }
    29
    
                                                    
                                                
    75.0% lib/openzeppelin-contracts/contracts/utils/math/Math.sol
    Lines covered: 9 / 12 (75.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    /**
    7
     * @dev Standard math utilities missing in the Solidity language.
    8
     */
    9
    ✓ 13
    library Math {
    10
        /**
    11
         * @dev Muldiv operation overflow.
    12
         */
    13
        error MathOverflowedMulDiv();
    14
    
                                                    
                                                
    15
        enum Rounding {
    16
            Floor, // Toward negative infinity
    17
            Ceil, // Toward positive infinity
    18
            Trunc, // Toward zero
    19
            Expand // Away from zero
    20
        }
    21
    
                                                    
                                                
    22
        /**
    23
         * @dev Returns the addition of two unsigned integers, with an overflow flag.
    24
         */
    25
        function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    26
            unchecked {
    27
                uint256 c = a + b;
    28
                if (c < a) return (false, 0);
    29
                return (true, c);
    30
            }
    31
        }
    32
    
                                                    
                                                
    33
        /**
    34
         * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
    35
         */
    36
        function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    37
            unchecked {
    38
                if (b > a) return (false, 0);
    39
                return (true, a - b);
    40
            }
    41
        }
    42
    
                                                    
                                                
    43
        /**
    44
         * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
    45
         */
    46
        function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    47
            unchecked {
    48
                // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    49
                // benefit is lost if 'b' is also tested.
    50
                // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
    51
                if (a == 0) return (true, 0);
    52
                uint256 c = a * b;
    53
                if (c / a != b) return (false, 0);
    54
                return (true, c);
    55
            }
    56
        }
    57
    
                                                    
                                                
    58
        /**
    59
         * @dev Returns the division of two unsigned integers, with a division by zero flag.
    60
         */
    61
        function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    62
            unchecked {
    63
                if (b == 0) return (false, 0);
    64
                return (true, a / b);
    65
            }
    66
        }
    67
    
                                                    
                                                
    68
        /**
    69
         * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
    70
         */
    71
        function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    72
            unchecked {
    73
                if (b == 0) return (false, 0);
    74
                return (true, a % b);
    75
            }
    76
        }
    77
    
                                                    
                                                
    78
        /**
    79
         * @dev Returns the largest of two numbers.
    80
         */
    81
        function max(uint256 a, uint256 b) internal pure returns (uint256) {
    82
            return a > b ? a : b;
    83
        }
    84
    
                                                    
                                                
    85
        /**
    86
         * @dev Returns the smallest of two numbers.
    87
         */
    88
        function min(uint256 a, uint256 b) internal pure returns (uint256) {
    89
            return a < b ? a : b;
    90
        }
    91
    
                                                    
                                                
    92
        /**
    93
         * @dev Returns the average of two numbers. The result is rounded towards
    94
         * zero.
    95
         */
    96
        function average(uint256 a, uint256 b) internal pure returns (uint256) {
    97
            // (a + b) / 2 can overflow.
    98
            return (a & b) + (a ^ b) / 2;
    99
        }
    100
    
                                                    
                                                
    101
        /**
    102
         * @dev Returns the ceiling of the division of two numbers.
    103
         *
    104
         * This differs from standard division with `/` in that it rounds towards infinity instead
    105
         * of rounding towards zero.
    106
         */
    107
        function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
    108
            if (b == 0) {
    109
                // Guarantee the same behavior as in a regular Solidity division.
    110
                return a / b;
    111
            }
    112
    
                                                    
                                                
    113
            // (a + b - 1) / b can overflow on addition, so we distribute.
    114
            return a == 0 ? 0 : (a - 1) / b + 1;
    115
        }
    116
    
                                                    
                                                
    117
        /**
    118
         * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
    119
         * denominator == 0.
    120
         * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
    121
         * Uniswap Labs also under MIT license.
    122
         */
    123
        function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
    124
            unchecked {
    125
                // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
    126
                // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
    127
                // variables such that product = prod1 * 2^256 + prod0.
    128
                uint256 prod0 = x * y; // Least significant 256 bits of the product
    129
                uint256 prod1; // Most significant 256 bits of the product
    130
    ✓ 3.9K
                assembly {
    131
                    let mm := mulmod(x, y, not(0))
    132
                    prod1 := sub(sub(mm, prod0), lt(mm, prod0))
    133
                }
    134
    
                                                    
                                                
    135
                // Handle non-overflow cases, 256 by 256 division.
    136
    ✓ 3.9K
                if (prod1 == 0) {
    137
                    // Solidity will revert if denominator == 0, unlike the div opcode on its own.
    138
                    // The surrounding unchecked block does not change this fact.
    139
                    // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
    140
    ✓ 3.9K
                    return prod0 / denominator;
    141
                }
    142
    
                                                    
                                                
    143
                // Make sure the result is less than 2^256. Also prevents denominator == 0.
    144
    ✓ 453
                if (denominator <= prod1) {
    145
    ✓ 234
    ⟲ 234
                    revert MathOverflowedMulDiv();
    146
                }
    147
    
                                                    
                                                
    148
                ///////////////////////////////////////////////
    149
                // 512 by 256 division.
    150
                ///////////////////////////////////////////////
    151
    
                                                    
                                                
    152
                // Make division exact by subtracting the remainder from [prod1 prod0].
    153
                uint256 remainder;
    154
    ✓ 219
                assembly {
    155
                    // Compute remainder using mulmod.
    156
                    remainder := mulmod(x, y, denominator)
    157
    
                                                    
                                                
    158
                    // Subtract 256 bit number from 512 bit number.
    159
                    prod1 := sub(prod1, gt(remainder, prod0))
    160
                    prod0 := sub(prod0, remainder)
    161
                }
    162
    
                                                    
                                                
    163
                // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
    164
                // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
    165
    
                                                    
                                                
    166
                uint256 twos = denominator & (0 - denominator);
    167
    ✓ 219
                assembly {
    168
                    // Divide denominator by twos.
    169
                    denominator := div(denominator, twos)
    170
    
                                                    
                                                
    171
                    // Divide [prod1 prod0] by twos.
    172
                    prod0 := div(prod0, twos)
    173
    
                                                    
                                                
    174
                    // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
    175
                    twos := add(div(sub(0, twos), twos), 1)
    176
                }
    177
    
                                                    
                                                
    178
                // Shift in bits from prod1 into prod0.
    179
    ✓ 219
                prod0 |= prod1 * twos;
    180
    
                                                    
                                                
    181
                // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
    182
                // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
    183
                // four bits. That is, denominator * inv = 1 mod 2^4.
    184
                uint256 inverse = (3 * denominator) ^ 2;
    185
    
                                                    
                                                
    186
                // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
    187
                // works in modular arithmetic, doubling the correct bits in each step.
    188
                inverse *= 2 - denominator * inverse; // inverse mod 2^8
    189
                inverse *= 2 - denominator * inverse; // inverse mod 2^16
    190
                inverse *= 2 - denominator * inverse; // inverse mod 2^32
    191
                inverse *= 2 - denominator * inverse; // inverse mod 2^64
    192
                inverse *= 2 - denominator * inverse; // inverse mod 2^128
    193
                inverse *= 2 - denominator * inverse; // inverse mod 2^256
    194
    
                                                    
                                                
    195
                // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
    196
                // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
    197
                // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
    198
                // is no longer required.
    199
                result = prod0 * inverse;
    200
                return result;
    201
            }
    202
        }
    203
    
                                                    
                                                
    204
        /**
    205
         * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
    206
         */
    207
        function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
    208
            uint256 result = mulDiv(x, y, denominator);
    209
            if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
    210
                result += 1;
    211
            }
    212
            return result;
    213
        }
    214
    
                                                    
                                                
    215
        /**
    216
         * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
    217
         * towards zero.
    218
         *
    219
         * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
    220
         */
    221
        function sqrt(uint256 a) internal pure returns (uint256) {
    222
            if (a == 0) {
    223
                return 0;
    224
            }
    225
    
                                                    
                                                
    226
            // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
    227
            //
    228
            // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
    229
            // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
    230
            //
    231
            // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
    232
            // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
    233
            // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
    234
            //
    235
            // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
    236
            uint256 result = 1 << (log2(a) >> 1);
    237
    
                                                    
                                                
    238
            // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
    239
            // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
    240
            // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
    241
            // into the expected uint128 result.
    242
            unchecked {
    243
                result = (result + a / result) >> 1;
    244
                result = (result + a / result) >> 1;
    245
                result = (result + a / result) >> 1;
    246
                result = (result + a / result) >> 1;
    247
                result = (result + a / result) >> 1;
    248
                result = (result + a / result) >> 1;
    249
                result = (result + a / result) >> 1;
    250
                return min(result, a / result);
    251
            }
    252
        }
    253
    
                                                    
                                                
    254
        /**
    255
         * @notice Calculates sqrt(a), following the selected rounding direction.
    256
         */
    257
        function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
    258
            unchecked {
    259
                uint256 result = sqrt(a);
    260
                return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
    261
            }
    262
        }
    263
    
                                                    
                                                
    264
        /**
    265
         * @dev Return the log in base 2 of a positive value rounded towards zero.
    266
         * Returns 0 if given 0.
    267
         */
    268
        function log2(uint256 value) internal pure returns (uint256) {
    269
            uint256 result = 0;
    270
            unchecked {
    271
                if (value >> 128 > 0) {
    272
                    value >>= 128;
    273
                    result += 128;
    274
                }
    275
                if (value >> 64 > 0) {
    276
                    value >>= 64;
    277
                    result += 64;
    278
                }
    279
                if (value >> 32 > 0) {
    280
                    value >>= 32;
    281
                    result += 32;
    282
                }
    283
                if (value >> 16 > 0) {
    284
                    value >>= 16;
    285
                    result += 16;
    286
                }
    287
                if (value >> 8 > 0) {
    288
                    value >>= 8;
    289
                    result += 8;
    290
                }
    291
                if (value >> 4 > 0) {
    292
                    value >>= 4;
    293
                    result += 4;
    294
                }
    295
                if (value >> 2 > 0) {
    296
                    value >>= 2;
    297
                    result += 2;
    298
                }
    299
                if (value >> 1 > 0) {
    300
                    result += 1;
    301
                }
    302
            }
    303
            return result;
    304
        }
    305
    
                                                    
                                                
    306
        /**
    307
         * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
    308
         * Returns 0 if given 0.
    309
         */
    310
        function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
    311
            unchecked {
    312
                uint256 result = log2(value);
    313
                return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
    314
            }
    315
        }
    316
    
                                                    
                                                
    317
        /**
    318
         * @dev Return the log in base 10 of a positive value rounded towards zero.
    319
         * Returns 0 if given 0.
    320
         */
    321
        function log10(uint256 value) internal pure returns (uint256) {
    322
            uint256 result = 0;
    323
            unchecked {
    324
                if (value >= 10 ** 64) {
    325
                    value /= 10 ** 64;
    326
                    result += 64;
    327
                }
    328
                if (value >= 10 ** 32) {
    329
                    value /= 10 ** 32;
    330
                    result += 32;
    331
                }
    332
                if (value >= 10 ** 16) {
    333
                    value /= 10 ** 16;
    334
                    result += 16;
    335
                }
    336
                if (value >= 10 ** 8) {
    337
                    value /= 10 ** 8;
    338
                    result += 8;
    339
                }
    340
                if (value >= 10 ** 4) {
    341
                    value /= 10 ** 4;
    342
                    result += 4;
    343
                }
    344
                if (value >= 10 ** 2) {
    345
                    value /= 10 ** 2;
    346
                    result += 2;
    347
                }
    348
                if (value >= 10 ** 1) {
    349
                    result += 1;
    350
                }
    351
            }
    352
            return result;
    353
        }
    354
    
                                                    
                                                
    355
        /**
    356
         * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
    357
         * Returns 0 if given 0.
    358
         */
    359
        function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
    360
            unchecked {
    361
                uint256 result = log10(value);
    362
                return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
    363
            }
    364
        }
    365
    
                                                    
                                                
    366
        /**
    367
         * @dev Return the log in base 256 of a positive value rounded towards zero.
    368
         * Returns 0 if given 0.
    369
         *
    370
         * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
    371
         */
    372
        function log256(uint256 value) internal pure returns (uint256) {
    373
            uint256 result = 0;
    374
            unchecked {
    375
                if (value >> 128 > 0) {
    376
                    value >>= 128;
    377
                    result += 16;
    378
                }
    379
                if (value >> 64 > 0) {
    380
                    value >>= 64;
    381
                    result += 8;
    382
                }
    383
                if (value >> 32 > 0) {
    384
                    value >>= 32;
    385
                    result += 4;
    386
                }
    387
                if (value >> 16 > 0) {
    388
                    value >>= 16;
    389
                    result += 2;
    390
                }
    391
                if (value >> 8 > 0) {
    392
                    result += 1;
    393
                }
    394
            }
    395
            return result;
    396
        }
    397
    
                                                    
                                                
    398
        /**
    399
         * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
    400
         * Returns 0 if given 0.
    401
         */
    402
        function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
    403
            unchecked {
    404
                uint256 result = log256(value);
    405
                return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
    406
            }
    407
        }
    408
    
                                                    
                                                
    409
        /**
    410
         * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
    411
         */
    412
        function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
    413
            return uint8(rounding) % 2 == 1;
    414
        }
    415
    }
    416
    
                                                    
                                                
    0.0% script/DeployKittyFi.s.sol
    Lines covered: 0 / 9 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    
                                                    
                                                
    3
    pragma solidity 0.8.26;
    4
    
                                                    
                                                
    5
    import { KittyPool } from "src/KittyPool.sol";
    6
    import { KittyCoin } from "src/KittyCoin.sol";
    7
    import { KittyVault } from "src/KittyVault.sol";
    8
    import { Script } from "forge-std/Script.sol";
    9
    import { HelperConfig } from "./HelperConfig.s.sol";
    10
    
                                                    
                                                
    11
    contract DeployKittyFi is Script {
    12
        function run() external returns (KittyPool, KittyCoin, KittyVault) {
    13
            HelperConfig helperConfig = new HelperConfig();
    14
            HelperConfig.NetworkConfig memory config = helperConfig.getNetworkConfig();
    15
    
                                                    
                                                
    16
            vm.startBroadcast();
    17
            KittyPool kittyPool = new KittyPool(msg.sender, config.euroPriceFeed, config.aavePool);
    18
            kittyPool.meownufactureKittyVault(config.weth, config.ethUsdPriceFeed);
    19
            vm.stopBroadcast();
    20
    
                                                    
                                                
    21
            KittyCoin kittyCoin = KittyCoin(kittyPool.getKittyCoin());
    22
            KittyVault wethVault = KittyVault(kittyPool.getTokenToVault(config.weth));
    23
    
                                                    
                                                
    24
            return (kittyPool, kittyCoin, wethVault);
    25
        }
    26
    }
    0.0% script/HelperConfig.s.sol
    Lines covered: 0 / 10 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    
                                                    
                                                
    3
    pragma solidity 0.8.26;
    4
    
                                                    
                                                
    5
    import { Script } from "forge-std/Script.sol";
    6
    
                                                    
                                                
    7
    contract HelperConfig is Script {
    8
        struct NetworkConfig {
    9
            address aavePool;
    10
            address euroPriceFeed;
    11
            address ethUsdPriceFeed;
    12
            address btcUsdPriceFeed;
    13
            address usdcUsdPriceFeed;
    14
            address weth;
    15
            address wbtc;
    16
            address usdc;
    17
        }
    18
    
                                                    
                                                
    19
        NetworkConfig private networkConfig;
    20
    
                                                    
                                                
    21
        constructor() {
    22
            if (block.chainid == 11155111) {
    23
                networkConfig = getSepoliaConfig();
    24
            }
    25
        }
    26
    
                                                    
                                                
    27
        function getSepoliaConfig() internal pure returns (NetworkConfig memory) {
    28
            return NetworkConfig ({
    29
                aavePool: 0x6Ae43d3271ff6888e7Fc43Fd7321a503ff738951,
    30
                euroPriceFeed: 0x1a81afB8146aeFfCFc5E50e8479e826E7D55b910,
    31
                ethUsdPriceFeed: 0x694AA1769357215DE4FAC081bf1f309aDC325306,
    32
                btcUsdPriceFeed: 0x694AA1769357215DE4FAC081bf1f309aDC325306,
    33
                usdcUsdPriceFeed: 0xA2F78ab2355fe2f984D808B5CeE7FD0A93D5270E,
    34
                weth: 0xC558DBdd856501FCd9aaF1E62eae57A9F0629a3c,
    35
                wbtc: 0x29f2D40B0605204364af54EC677bD022dA425d03,
    36
                usdc: 0x94a9D9AC8a22534E3FaCa9F4e7F2E2cf85d5E4C8
    37
            });
    38
        }
    39
    
                                                    
                                                
    40
        function getNetworkConfig() external view returns (NetworkConfig memory) {
    41
            return networkConfig;
    42
        }
    43
    }
    100.0% src/KittyCoin.sol
    Lines covered: 2 / 2 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    
                                                    
                                                
    3
    pragma solidity 0.8.26;
    4
    
                                                    
                                                
    5
    import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    6
    
                                                    
                                                
    7
    contract KittyCoin is ERC20 {
    8
        error KittyCoin__OnlyKittyPoolCanMintOrBurn();
    9
    
                                                    
                                                
    10
        address private pool;
    11
    
                                                    
                                                
    12
        modifier onlyKittyPool() {
    13
    ✓ 762
            require(msg.sender == pool, KittyCoin__OnlyKittyPoolCanMintOrBurn());
    14
            _;
    15
        }
    16
    
                                                    
                                                
    17
        constructor(address _pool) ERC20("Kitty Token", "MEOWDY") {
    18
    ✓ 1
            pool = _pool;
    19
        }
    20
    
                                                    
                                                
    21
        function mint(address _to, uint256 _amount) external onlyKittyPool {
    22
            _mint(_to, _amount);
    23
        }
    24
    
                                                    
                                                
    25
        function burn(address _from, uint256 _amount) external onlyKittyPool {
    26
            _burn(_from, _amount);
    27
        }
    28
    }
    56.5% src/KittyPool.sol
    Lines covered: 26 / 46 (56.5%)
    1
    // SPDX-License-Identifier: MIT
    2
    
                                                    
                                                
    3
    pragma solidity 0.8.26;
    4
    
                                                    
                                                
    5
    import { KittyCoin } from "./KittyCoin.sol";
    6
    import { KittyVault, IKittyVault } from "./KittyVault.sol";
    7
    import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    8
    import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
    9
    
                                                    
                                                
    10
    /**
    11
     * @title KittyPool
    12
     * @author Shikhar Agarwal
    13
     * @notice This pool facilitates the depositing of collateral and minting of Meowdy coin
    14
     * The pool interact with the respective vault for a token to deposit collateral
    15
     * This pool also maintains the liquidation of bad debt position in order keep the KittyCoin safe.
    16
     */
    17
    
                                                    
                                                
    18
    contract KittyPool {
    19
        using Math for uint256;
    20
    
                                                    
                                                
    21
        error KittyPool__NotMeowntainerPurrrrr();
    22
        error KittyPool__TokenNotFoundMeeoooww();
    23
        error KittyPool__NotEnoughMeowllateralPurrrr();
    24
        error KittyPool__TokenAlreadyExistsMeeoooww();
    25
        error KittyPool__UserIsPurrfect();
    26
    
                                                    
                                                
    27
        address private meowntainer;
    28
        mapping(address token => address vault) private tokenToVault;
    29
        address[] private vaults;
    30
        KittyCoin private immutable i_kittyCoin;
    31
        address private immutable i_euroPriceFeed;
    32
        address private immutable i_aavePool;
    33
        mapping(address user => uint256 debt) private kittyCoinMeownted;
    34
    
                                                    
                                                
    35
    ✓ 1.3K
        uint256 private constant COLLATERAL_PERCENT = 169;
    36
    ✓ 833
        uint256 private constant COLLATERAL_PRECISION = 100;
    37
        uint256 private constant REWARD_PERCENT = 0.05e18;
    38
        uint256 private constant PRECISION = 1e18;
    39
    
                                                    
                                                
    40
        modifier onlyMeowntainer() {
    41
    ✓ 1
            require(msg.sender == meowntainer, KittyPool__NotMeowntainerPurrrrr());
    42
            _;
    43
        }
    44
    
                                                    
                                                
    45
        modifier tokenExists(address _token) {
    46
    ✓ 1.4K
            require(tokenToVault[_token] != address(0), KittyPool__TokenNotFoundMeeoooww());
    47
            _;
    48
        }
    49
        
    50
        /**
    51
         * 
    52
         * @param _meowntainer The maintainer of protocol, performs executions related to Aaves
    53
         * @param _euroPriceFeed The chainlink oracle price feed address for EURO
    54
         * @param aavePool The aave pool address on which collateral is supplied to yield interest
    55
         */
    56
        constructor(address _meowntainer, address _euroPriceFeed, address aavePool) {
    57
            meowntainer = _meowntainer;
    58
    ✓ 1
            i_kittyCoin = new KittyCoin(address(this));
    59
    ✓ 1
            i_euroPriceFeed = _euroPriceFeed;
    60
    ✓ 1
            i_aavePool = aavePool;
    61
        }
    62
    
                                                    
                                                
    63
        /**
    64
         * @notice Creates a Vault for the token
    65
         * @dev The vault created maintains all the accounting of the collateral
    66
         * @param _token address of collateral token for which vault is created
    67
         * @param _priceFeed price feed for the token (TOKEN / USD)
    68
         */
    69
        function meownufactureKittyVault(address _token, address _priceFeed) external onlyMeowntainer {
    70
    ✓ 1
            require(tokenToVault[_token] == address(0), KittyPool__TokenAlreadyExistsMeeoooww());
    71
    
                                                    
                                                
    72
    ✓ 1
            address _kittyVault = address(new KittyVault{ salt: bytes32(abi.encodePacked(ERC20(_token).symbol())) }(_token, address(this), _priceFeed, i_euroPriceFeed, meowntainer, i_aavePool));
    73
    
                                                    
                                                
    74
            tokenToVault[_token] = _kittyVault;
    75
    ✓ 1
            vaults.push(_kittyVault);
    76
        } 
    77
    
                                                    
                                                
    78
        /**
    79
         * @notice Deposits the collateral in the vault
    80
         * @param _token token address
    81
         * @param _ameownt amount of token to deposit
    82
         */
    83
        function depawsitMeowllateral(address _token, uint256 _ameownt) external tokenExists(_token) {
    84
    ✓ 1.4K
            IKittyVault(tokenToVault[_token]).executeDepawsit(msg.sender, _ameownt);
    85
        } 
    86
    
                                                    
                                                
    87
        /**
    88
         * @notice Withdraws the collateral from the vault
    89
         * @param _token token address
    90
         * @param _ameownt amount of catty nip (shares), corresponding to which collateral is withdrawn
    91
         */
    92
        function whiskdrawMeowllateral(address _token, uint256 _ameownt) external tokenExists(_token) {
    93
    ✓ 1.0K
            IKittyVault(tokenToVault[_token]).executeWhiskdrawal(msg.sender, _ameownt);
    94
            require(_hasEnoughMeowllateral(msg.sender), KittyPool__NotEnoughMeowllateralPurrrr());
    95
        }
    96
    
                                                    
                                                
    97
        /**
    98
         * @notice Mints the KittyCoin for the user
    99
         * @param _ameownt amount of KittyCoin to mint
    100
         */
    101
        function meowintKittyCoin(uint256 _ameownt) external {
    102
    ✓ 1.3K
            kittyCoinMeownted[msg.sender] += _ameownt;
    103
    ✓ 762
            i_kittyCoin.mint(msg.sender, _ameownt);
    104
    ✓ 1.3K
            require(_hasEnoughMeowllateral(msg.sender), KittyPool__NotEnoughMeowllateralPurrrr());
    105
        }
    106
    
                                                    
                                                
    107
        /**
    108
         * @notice Burns the KittyCoin for the user
    109
         * @param _onBehalfOf address of the user for which debt is reduced
    110
         * @param _ameownt amount of KittyCoin to burn
    111
         */
    112
        function burnKittyCoin(address _onBehalfOf, uint256 _ameownt) external {
    113
    ✓ 636
            kittyCoinMeownted[_onBehalfOf] -= _ameownt;
    114
    ✓ 78
            i_kittyCoin.burn(msg.sender, _ameownt);
    115
        }
    116
    
                                                    
                                                
    117
        /**
    118
         * @notice Liquidates the bad debt position of the user
    119
         * @param _user address of the user
    120
         */
    121
        function purrgeBadPawsition(address _user) external returns (uint256 _totalAmountReceived) {
    122
            require(!(_hasEnoughMeowllateral(_user)), KittyPool__UserIsPurrfect());
    123
            uint256 totalDebt = kittyCoinMeownted[_user];
    124
    
                                                    
                                                
    125
            kittyCoinMeownted[_user] = 0;
    126
            i_kittyCoin.burn(msg.sender, totalDebt);
    127
    
                                                    
                                                
    128
            uint256 userMeowllateralInEuros = getUserMeowllateralInEuros(_user);
    129
    
                                                    
                                                
    130
            uint256 redeemPercent;
    131
    
                                                    
                                                
    132
            if (totalDebt >= userMeowllateralInEuros) {
    133
                redeemPercent = PRECISION;
    134
            }
    135
            else {
    136
                redeemPercent = totalDebt.mulDiv(PRECISION, userMeowllateralInEuros);
    137
            }
    138
    
                                                    
                                                
    139
    ✓ 1.3K
            uint256 vaults_length = vaults.length;
    140
    
                                                    
                                                
    141
            for (uint256 i; i < vaults_length; ) {
    142
                IKittyVault _vault = IKittyVault(vaults[i]);
    143
                uint256 vaultCollateral = _vault.getUserVaultMeowllateralInEuros(_user);
    144
                uint256 toDistribute = vaultCollateral.mulDiv(redeemPercent, PRECISION);
    145
                uint256 extraCollateral = vaultCollateral - toDistribute;
    146
    
                                                    
                                                
    147
                uint256 extraReward = toDistribute.mulDiv(REWARD_PERCENT, PRECISION);
    148
                extraReward = Math.min(extraReward, extraCollateral);
    149
                _totalAmountReceived += (toDistribute + extraReward);
    150
    
                                                    
                                                
    151
                _vault.executeWhiskdrawal(msg.sender, toDistribute + extraReward);
    152
    
                                                    
                                                
    153
                unchecked {
    154
                    ++i;
    155
                }
    156
            }
    157
        }
    158
    
                                                    
                                                
    159
        /**
    160
         * @notice Checks if the user has enough Meowllateral
    161
         * @param _user address of the user
    162
         * @return hasEnoughCollateral true if user has enough Meowllateral
    163
         */
    164
        function _hasEnoughMeowllateral(address _user) internal view returns (bool hasEnoughCollateral) {
    165
    ✓ 1.3K
            uint256 totalCollateralInEuros = getUserMeowllateralInEuros(_user);
    166
    ✓ 1.3K
            uint256 collateralRequiredInEuros = kittyCoinMeownted[_user].mulDiv(COLLATERAL_PERCENT, COLLATERAL_PRECISION);
    167
    
                                                    
                                                
    168
    ✓ 1.1K
            return totalCollateralInEuros >= collateralRequiredInEuros;
    169
        }
    170
    
                                                    
                                                
    171
        /**
    172
         * @notice Gets the total Meowllateral of the user for all vaults
    173
         * @param _user address of the user
    174
         * @return totalUserMeowllateral total Meowllateral of the user
    175
         */
    176
        function getUserMeowllateralInEuros(address _user) public view returns (uint256 totalUserMeowllateral) {
    177
    ✓ 1.3K
            uint256 vault_length = vaults.length;
    178
    
                                                    
                                                
    179
    ✓ 2.6K
            for (uint256 i; i < vault_length; ) {
    180
    ✓ 1.3K
                totalUserMeowllateral += IKittyVault(vaults[i]).getUserVaultMeowllateralInEuros(_user);
    181
    
                                                    
                                                
    182
                unchecked {
    183
                    ++i;
    184
                }
    185
            }
    186
        }
    187
    
                                                    
                                                
    188
        function getAavePool() external view returns (address) {
    189
            return i_aavePool;
    190
        }
    191
    
                                                    
                                                
    192
        function getMeowntainer() external view returns (address) {
    193
            return meowntainer;
    194
        }
    195
    
                                                    
                                                
    196
        function getKittyCoin() external view returns (address) {
    197
    ✓ 1
            return address(i_kittyCoin);
    198
        }
    199
    
                                                    
                                                
    200
        function getTokenToVault(address _token) external view returns (address) {
    201
    ✓ 1
            return tokenToVault[_token];
    202
        }
    203
    
                                                    
                                                
    204
        function getKittyCoinMeownted(address _user) external view returns (uint256) {
    205
            return kittyCoinMeownted[_user];
    206
        }
    207
    }
    83.7% src/KittyVault.sol
    Lines covered: 36 / 43 (83.7%)
    1
    // SPDX-License-Identifier: MIT
    2
    
                                                    
                                                
    3
    pragma solidity 0.8.26;
    4
    
                                                    
                                                
    5
    import { ERC20, IERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    6
    import { IKittyVault } from "./interfaces/IKittyVault.sol";
    7
    import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
    8
    import { AggregatorV3Interface } from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
    9
    import { IAavePool } from "./interfaces/IAavePool.sol";
    10
    import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
    11
    
                                                    
                                                
    12
    contract KittyVault {
    13
        using SafeERC20 for IERC20;
    14
        using Math for uint256;
    15
    
                                                    
                                                
    16
        error KittyVault__NotPool();
    17
        error KittyVault__NotMeowntainerPurrrrr();
    18
    
                                                    
                                                
    19
        address public immutable i_token;
    20
        address public immutable i_pool;
    21
        AggregatorV3Interface public immutable i_priceFeed;
    22
        AggregatorV3Interface public immutable i_euroPriceFeed;
    23
        address public meowntainer;
    24
        IAavePool public immutable i_aavePool;
    25
    ✓ 2.8K
        uint256 public totalMeowllateralInVault;
    26
    
                                                    
                                                
    27
        /// @notice holds the user's shares of collateral (proportion)
    28
        /// @dev cattyNip cattyNip I want a mouse, catch me a mouse as fast as I meow
    29
    ✓ 5.8K
        mapping(address user => uint256 cattyNip) public userToCattyNip;
    30
    ✓ 3.4K
        uint256 public totalCattyNip;
    31
    
                                                    
                                                
    32
    ✓ 3.9K
        uint256 private constant EXTRA_DECIMALS = 1e10;
    33
    ✓ 3.9K
        uint256 private constant PRECISION = 1e18;
    34
    
                                                    
                                                
    35
        modifier onlyMeowntainer {
    36
    ✓ 106
            require(msg.sender == meowntainer, KittyVault__NotMeowntainerPurrrrr());
    37
            _;
    38
        }
    39
    
                                                    
                                                
    40
        modifier onlyPool() {
    41
    ✓ 1.4K
            require(msg.sender == i_pool, KittyVault__NotPool());
    42
            _;
    43
        }
    44
    
                                                    
                                                
    45
        /**
    46
         * 
    47
         * @param _token the collateral token of this vault
    48
         * @param _pool The KittyPool address
    49
         * @param _priceFeed Price feed for the collateral token of vault
    50
         * @param _euroPriceFeed Price feed for euro
    51
         * @param _meowntainer The maintainer of the executions related to Aave supply and withdraw
    52
         * @param _aavePool The aave pool address on which collateral is supplied to yield interest
    53
         */
    54
        constructor(address _token, address _pool, address _priceFeed, address _euroPriceFeed, address _meowntainer, address _aavePool) {
    55
    ✓ 1
            i_token = _token;
    56
    ✓ 1
            i_pool = _pool;
    57
    ✓ 1
            i_priceFeed = AggregatorV3Interface(_priceFeed);
    58
    ✓ 1
            i_euroPriceFeed = AggregatorV3Interface(_euroPriceFeed);
    59
            meowntainer = _meowntainer;
    60
    ✓ 1
            i_aavePool = IAavePool(_aavePool);
    61
        }
    62
    
                                                    
                                                
    63
        /**
    64
         * @param _user The user who wants to deposit collateral
    65
         * @param _ameownt The amount of collateral to deposit
    66
         */
    67
        function executeDepawsit(address _user, uint256 _ameownt) external onlyPool {
    68
            uint256 _totalMeowllateral = getTotalMeowllateral();
    69
            uint256 _cattyNipGenerated;
    70
    
                                                    
                                                
    71
    ✓ 1.4K
            if (_totalMeowllateral == 0) {
    72
    ✓ 201
                _cattyNipGenerated = _ameownt;
    73
            }
    74
            else {
    75
    ✓ 1.2K
                _cattyNipGenerated = _ameownt.mulDiv(totalCattyNip, _totalMeowllateral);
    76
            }
    77
    
                                                    
                                                
    78
    ✓ 1.4K
            userToCattyNip[_user] += _cattyNipGenerated;
    79
    ✓ 1.4K
            totalCattyNip += _cattyNipGenerated;
    80
    ✓ 1.4K
            totalMeowllateralInVault += _ameownt;
    81
    
                                                    
                                                
    82
    ✓ 1.4K
            IERC20(i_token).safeTransferFrom(_user, address(this), _ameownt);
    83
        }
    84
    
                                                    
                                                
    85
        /**
    86
         * @param _user The user who wants to withdraw collateral
    87
         * @param _cattyNipToWithdraw The amount of shares corresponding to collateral to withdraw
    88
         */
    89
        function executeWhiskdrawal(address _user, uint256 _cattyNipToWithdraw) external onlyPool {
    90
    ✓ 1.0K
            uint256 _ameownt = _cattyNipToWithdraw.mulDiv(getTotalMeowllateral(), totalCattyNip);
    91
    ✓ 977
            userToCattyNip[_user] -= _cattyNipToWithdraw;
    92
    ✓ 1.0K
            totalCattyNip -= _cattyNipToWithdraw;
    93
    ✓ 557
            totalMeowllateralInVault -= _ameownt;
    94
    
                                                    
                                                
    95
    ✓ 2.0K
            IERC20(i_token).safeTransfer(_user, _ameownt);
    96
        }
    97
    
                                                    
                                                
    98
    
                                                    
                                                
    99
        ////////////////////////////////////////////
    100
        ////////// AAVE SUPPLY FOR INTEREST ////////
    101
        //////////////////////////////////////////// 
    102
        
    103
        /**
    104
         * @notice Supplies collateral to Aave pool to earn interest
    105
         * @param _ameowntToSupply The amount of collateral to supply to Aave
    106
         */
    107
        function purrrCollateralToAave(uint256 _ameowntToSupply) external onlyMeowntainer {
    108
    ✓ 106
            totalMeowllateralInVault -= _ameowntToSupply;
    109
    ✓ 27
            IERC20(i_token).approve(address(i_aavePool), _ameowntToSupply);
    110
    ✓ 27
            i_aavePool.supply( { asset: i_token, amount: _ameowntToSupply, onBehalfOf: address(this), referralCode: 0 } );
    111
        }
    112
    
                                                    
                                                
    113
        /**
    114
         * @notice Withdraws collateral from Aave pool
    115
         * @param _ameowntToWhiskdraw The amount of collateral to withdraw from Aave
    116
         */
    117
        function purrrCollateralFromAave(uint256 _ameowntToWhiskdraw) external onlyMeowntainer {
    118
            totalMeowllateralInVault += _ameowntToWhiskdraw;
    119
            i_aavePool.withdraw( { asset: i_token, amount: _ameowntToWhiskdraw, to: address(this) } );
    120
        }
    121
    
                                                    
                                                
    122
        /**
    123
         * @notice Gets the user's collateral for this vault in euros
    124
         * @param _user The user for which the collateral is calculated
    125
         */
    126
        function getUserVaultMeowllateralInEuros(address _user) external view returns (uint256) {
    127
    ✓ 1.5K
            (, int256 collateralToUsdPrice, , , ) = i_priceFeed.latestRoundData();
    128
    ✓ 1.5K
            (, int256 euroPriceFeedAns, , ,) = i_euroPriceFeed.latestRoundData();
    129
    ✓ 1.5K
            uint256 collateralAns = getUserMeowllateral(_user).mulDiv(uint256(collateralToUsdPrice) * EXTRA_DECIMALS, PRECISION);
    130
    ✓ 1.5K
            return collateralAns.mulDiv(uint256(euroPriceFeedAns) * EXTRA_DECIMALS, PRECISION);
    131
        }
    132
    
                                                    
                                                
    133
        /**
    134
         * @notice Gets the user's collateral deposited
    135
         * @param _user The user for which the collateral is calculated
    136
         */
    137
        function getUserMeowllateral(address _user) public view returns (uint256) {
    138
            uint256 totalMeowllateralOfVault = getTotalMeowllateral();
    139
    ✓ 1.5K
            return userToCattyNip[_user].mulDiv(totalMeowllateralOfVault, totalCattyNip);
    140
        }
    141
    
                                                    
                                                
    142
        /**
    143
         * @notice Gets the total collateral in the vault and on aave
    144
         */
    145
        function getTotalMeowllateral() public view returns (uint256) {
    146
    ✓ 3.9K
            return totalMeowllateralInVault + getTotalMeowllateralInAave();
    147
        }
    148
    
                                                    
                                                
    149
        /**
    150
         * @notice Gets the total sum of collateral deposited in Aave and the collateral earned by interest from Aave
    151
         */
    152
        function getTotalMeowllateralInAave() public view returns (uint256) {
    153
    ✓ 3.9K
            (uint256 totalCollateralBase, , , , , ) = i_aavePool.getUserAccountData(address(this));
    154
    
                                                    
                                                
    155
    ✓ 3.9K
            (, int256 collateralToUsdPrice, , , ) = i_priceFeed.latestRoundData();
    156
    ✓ 3.9K
            return totalCollateralBase.mulDiv(PRECISION, uint256(collateralToUsdPrice) * EXTRA_DECIMALS);
    157
        }
    158
    }
    0.0% src/interfaces/IAavePool.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: AGPL-3.0
    2
    pragma solidity ^0.8.0;
    3
    
                                                    
                                                
    4
    /**
    5
     * @title IPool
    6
     * @author Aave
    7
     * @notice Defines the basic interface for an Aave Pool.
    8
     */
    9
    interface IAavePool {
    10
      function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
    11
    
                                                    
                                                
    12
      function withdraw(address asset, uint256 amount, address to) external returns (uint256);
    13
    
                                                    
                                                
    14
      function getUserAccountData(
    15
        address user
    16
      )
    17
        external
    18
        view
    19
        returns (
    20
          uint256 totalCollateralBase,
    21
          uint256 totalDebtBase,
    22
          uint256 availableBorrowsBase,
    23
          uint256 currentLiquidationThreshold,
    24
          uint256 ltv,
    25
          uint256 healthFactor
    26
        );
    27
    }
    0.0% src/interfaces/IKittyVault.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    
                                                    
                                                
    3
    pragma solidity 0.8.26;
    4
    
                                                    
                                                
    5
    interface IKittyVault {
    6
        function getUserVaultMeowllateralInEuros(address _user) external view returns (uint256);
    7
        function executeDepawsit(address _user, uint256 _ameownt) external;
    8
        function executeWhiskdrawal(address _user, uint256 _ameownt) external;
    9
    }
    92.7% test/Invariant/KittyInv.sol
    Lines covered: 51 / 55 (92.7%)
    1
    // SPDX-License-Identifier: MIT
    2
    
                                                    
                                                
    3
    pragma solidity 0.8.26;
    4
    
                                                    
                                                
    5
    import { Test, console } from "forge-std/Test.sol";
    6
    import { KittyCoin } from "src/KittyCoin.sol";
    7
    import { KittyPool } from "src/KittyPool.sol";
    8
    import { KittyVault, IAavePool } from "src/KittyVault.sol";
    9
    import { DeployKittyFi, HelperConfig } from "script/DeployKittyFi.s.sol";
    10
    import { ERC20Mock } from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";
    11
    import { MockV3Aggregator } from "@chainlink/contracts/src/v0.8/tests/MockV3Aggregator.sol";
    12
    import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
    13
    import { WETH9Mock } from "./Mocks/MockWeth.sol";
    14
    import "./Utils/Cheats.sol";
    15
    import "./Utils/PropertyHelper.sol";
    16
    import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
    17
    
                                                    
                                                
    18
    contract KittyInv is PropertiesAsserts {
    19
        using Math for uint256;
    20
    
                                                    
                                                
    21
    ✓ 1
        StdCheats vm = StdCheats(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
    22
    
                                                    
                                                
    23
        KittyCoin kittyCoin;
    24
        KittyPool kittyPool;
    25
        KittyVault wethVault;
    26
        
    27
        address meowntainer;
    28
    ✓ 1
        uint256 AMOUNT = 10e18;
    29
    
                                                    
                                                
    30
    ✓ 1
        address aavePool = 0x6Ae43d3271ff6888e7Fc43Fd7321a503ff738951;
    31
    ✓ 1
        address euroPriceFeed = 0x1a81afB8146aeFfCFc5E50e8479e826E7D55b910;
    32
    ✓ 1
        address ethUsdPriceFeed = 0x694AA1769357215DE4FAC081bf1f309aDC325306;
    33
    ✓ 1
        address btcUsdPriceFeed = 0x694AA1769357215DE4FAC081bf1f309aDC325306;
    34
    ✓ 1
        address usdcUsdPriceFeed = 0xA2F78ab2355fe2f984D808B5CeE7FD0A93D5270E;
    35
        WETH9Mock weth;
    36
    ✓ 1
        address wbtc = 0x29f2D40B0605204364af54EC677bD022dA425d03;
    37
    ✓ 1
        address usdc = 0x94a9D9AC8a22534E3FaCa9F4e7F2E2cf85d5E4C8;
    38
    
                                                    
                                                
    39
        uint totalCattyNip;
    40
    
                                                    
                                                
    41
    ✓ 235
        uint256 private constant COLLATERAL_PERCENT = 169;
    42
    ✓ 235
        uint256 private constant COLLATERAL_PRECISION = 100;
    43
    
                                                    
                                                
    44
        constructor() {
    45
    ✓ 1
            meowntainer = msg.sender;
    46
        
    47
    ✓ 1
            kittyPool = new KittyPool(meowntainer, euroPriceFeed, aavePool);
    48
    ✓ 1
            weth = new WETH9Mock("Weth Mock", "mWeth", address(this));
    49
    
                                                    
                                                
    50
    
                                                    
                                                
    51
    ✓ 1
            vm.prank(meowntainer);
    52
    ✓ 1
            kittyPool.meownufactureKittyVault(address(weth), ethUsdPriceFeed);
    53
    
                                                    
                                                
    54
    ✓ 1
            kittyCoin = KittyCoin(kittyPool.getKittyCoin());
    55
    ✓ 2
            wethVault = KittyVault(kittyPool.getTokenToVault(address(weth)));
    56
        }
    57
    
                                                    
                                                
    58
        // function testConstructorValuesSetUpCorrectly() public view {
    59
        //     assert(address(kittyPool.getMeowntainer()) == meowntainer);
    60
        //     assert(address(kittyPool.getKittyCoin()) == address(kittyCoin));
    61
        //     assert(address(kittyPool.getTokenToVault(address(weth))) == address(wethVault));
    62
        //     assert(address(kittyPool.getAavePool()) == aavePool);
    63
        // }
    64
    
                                                    
                                                
    65
        //  function test_MeowntainerAddingTokenSetUpCorrectly() public {
    66
        //     // initially there is no vault for wbtc
    67
        //     require(kittyPool.getTokenToVault(wbtc) == address(0));
    68
    
                                                    
                                                
    69
        //     vm.prank(meowntainer);
    70
        //     kittyPool.meownufactureKittyVault(wbtc, btcUsdPriceFeed);
    71
    
                                                    
                                                
    72
        //     address vaultCreated = kittyPool.getTokenToVault(wbtc);
    73
    
                                                    
                                                
    74
        //     require(vaultCreated != address(0), "Vault not created");
    75
    
                                                    
                                                
    76
        //     KittyVault _vault = KittyVault(vaultCreated);
    77
    
                                                    
                                                
    78
        //     assert(_vault.i_token() == wbtc);
    79
        //     assert(_vault.i_pool() == address(kittyPool));
    80
        //     assert(address(_vault.i_priceFeed()) == btcUsdPriceFeed);
    81
        //     assert(address(_vault.i_euroPriceFeed()) == euroPriceFeed);
    82
        //     assert(address(_vault.i_aavePool()) == aavePool);
    83
        //     assert(_vault.meowntainer() == meowntainer);
    84
        //     assert(address(_vault.i_aavePool()) == aavePool);
    85
        // }
    86
    
                                                    
                                                
    87
         function test_UserDepositsInVault(uint256 toDeposit) public {
    88
    ✓ 1.4K
            toDeposit = clampBetween(toDeposit, 1 ether, 100_000 ether);
    89
            
    90
    ✓ 1.4K
            weth.mint(msg.sender, toDeposit);
    91
    
                                                    
                                                
    92
    ✓ 1.4K
            uint256 userInitialBalance = wethVault.userToCattyNip(msg.sender);
    93
    
                                                    
                                                
    94
    ✓ 1.4K
            vm.prank(msg.sender);
    95
    ✓ 2.8K
            weth.approve(address(wethVault), toDeposit);
    96
    
                                                    
                                                
    97
    ✓ 1.4K
            vm.prank(msg.sender);
    98
    ✓ 1.4K
            kittyPool.depawsitMeowllateral(address(weth), toDeposit);
    99
    
                                                    
                                                
    100
    ✓ 1.4K
            totalCattyNip += toDeposit;
    101
    
                                                    
                                                
    102
    ✓ 1.4K
            uint256 userAfterBalance = wethVault.userToCattyNip(msg.sender);
    103
    
                                                    
                                                
    104
    ✓ 1.4K
            if (wethVault.totalMeowllateralInVault() > 0 ) {
    105
    ✓ 1.4K
               uint userShare =  toDeposit.mulDiv(wethVault.totalCattyNip(), wethVault.totalMeowllateralInVault());
    106
    ✓ 1.4K
                assert(wethVault.userToCattyNip(msg.sender) - userShare == userInitialBalance);
    107
            }
    108
    
                                                    
                                                
    109
    ✓ 3.4K
            assert(userAfterBalance - userInitialBalance == toDeposit);
    110
    ✓ 1.4K
            assert(wethVault.totalCattyNip() == totalCattyNip);
    111
            
    112
        }
    113
        // Check the total weth token value at every instance
    114
        function test_vaultWethBalance() public view {
    115
            assert(weth.balanceOf(address(wethVault)) == totalCattyNip);
    116
        }
    117
    
                                                    
                                                
    118
        function test_UserWithdrawsInVault(uint amount) public {
    119
    ✓ 2.4K
            amount = clampBetween(amount, 1 ether, 100_000 ether);
    120
    
                                                    
                                                
    121
    ✓ 1.0K
            uint256 userInitialBalance = wethVault.userToCattyNip(msg.sender);
    122
            
    123
    ✓ 1.0K
            vm.prank(msg.sender);
    124
    ✓ 1.0K
            kittyPool.whiskdrawMeowllateral(address(weth), amount);
    125
    
                                                    
                                                
    126
    ✓ 557
            totalCattyNip -= amount;
    127
    
                                                    
                                                
    128
    ✓ 557
            uint256 userAfterBalance = wethVault.userToCattyNip(msg.sender);
    129
    
                                                    
                                                
    130
    
                                                    
                                                
    131
    ✓ 557
            assert(wethVault.totalCattyNip() == totalCattyNip);
    132
    ✓ 557
            assert(userInitialBalance - amount  == userAfterBalance);
    133
        }
    134
    
                                                    
                                                
    135
        function test_userMintCattyNip(uint amount) public {
    136
    
                                                    
                                                
    137
    ✓ 793
            vm.prank(msg.sender);
    138
    ✓ 793
            kittyPool.meowintKittyCoin(amount);
    139
            // check underCollateral minting 
    140
    ✓ 235
            assert(wethVault.getUserVaultMeowllateralInEuros(msg.sender)  >= kittyCoin.balanceOf(msg.sender).mulDiv(COLLATERAL_PERCENT, COLLATERAL_PRECISION));
    141
        }
    142
    
                                                    
                                                
    143
        function test_userKittyCoinisSolvency() public view {
    144
            assert(wethVault.getUserVaultMeowllateralInEuros(msg.sender)  >= kittyCoin.balanceOf(msg.sender).mulDiv(COLLATERAL_PERCENT, COLLATERAL_PRECISION));
    145
        }
    146
    
                                                    
                                                
    147
        function test_userBurnCattyNip(uint256 amount, address user) public {
    148
    ✓ 636
            uint userInitialBalance = kittyCoin.balanceOf(msg.sender);
    149
    
                                                    
                                                
    150
    ✓ 636
            vm.prank(msg.sender);
    151
    ✓ 636
            kittyPool.burnKittyCoin(user, amount);
    152
    
                                                    
                                                
    153
    ✓ 75
            uint userAfterBalance = kittyCoin.balanceOf(msg.sender);
    154
    
                                                    
                                                
    155
    ✓ 75
            assert(userAfterBalance + amount == userInitialBalance);
    156
    
                                                    
                                                
    157
        }
    158
    
                                                    
                                                
    159
        function test_ownerSupplyToAave(uint256 amount) public {
    160
    ✓ 106
            uint vaultInitialBalance = weth.balanceOf(address(wethVault));
    161
    
                                                    
                                                
    162
    ✓ 106
            vm.prank(meowntainer);
    163
    ✓ 106
            wethVault.purrrCollateralToAave(amount);
    164
        
    165
            uint vaultAfterBalance = weth.balanceOf(address(wethVault));
    166
            
    167
        
    168
            assert(vaultInitialBalance - amount == vaultAfterBalance);
    169
    
                                                    
                                                
    170
        }
    171
    
                                                    
                                                
    172
        
    173
    }
    100.0% test/Invariant/Mocks/MockWeth.sol
    Lines covered: 3 / 3 (100.0%)
    1
    // SPDX-License-Identifier: BUSL-1.1
    2
    pragma solidity ^0.8.0;
    3
    
                                                    
                                                
    4
    import {WETH9} from "@aave/core-v3/contracts/dependencies/weth/WETH9.sol";
    5
    import {Ownable} from "@aave/core-v3/contracts/dependencies/openzeppelin/contracts/Ownable.sol";
    6
    
                                                    
                                                
    7
    ✓ 4
    contract WETH9Mock is WETH9, Ownable {
    8
        constructor(
    9
            string memory mockName,
    10
            string memory mockSymbol,
    11
            address owner
    12
        ) {
    13
            name = mockName;
    14
            symbol = mockSymbol;
    15
    
                                                    
                                                
    16
            transferOwnership(owner);
    17
        }
    18
    
                                                    
                                                
    19
        function mint(address account, uint256 value)
    20
            public
    21
            // onlyOwner
    22
            returns (bool)
    23
        {
    24
    ✓ 1.4K
            balanceOf[account] += value;
    25
    ✓ 1.4K
            emit Transfer(address(0), account, value);
    26
            return true;
    27
        }
    28
    }
    0.0% test/Invariant/Utils/Cheats.sol
    Lines covered: 0 / 0 (0.0%)
    1
    interface StdCheats {
    2
        // Set block.timestamp
    3
        function warp(uint256) external;
    4
    
                                                    
                                                
    5
        // Set block.number
    6
        function roll(uint256) external;
    7
    
                                                    
                                                
    8
        // Set block.basefee
    9
        function fee(uint256) external;
    10
    
                                                    
                                                
    11
        // Set block.difficulty and block.prevrandao
    12
        function difficulty(uint256) external;
    13
    
                                                    
                                                
    14
        // Set block.chainid
    15
        function chainId(uint256) external;
    16
    
                                                    
                                                
    17
        // Sets the block.coinbase
    18
        function coinbase(address) external;
    19
    
                                                    
                                                
    20
        // Loads a storage slot from an address
    21
        function load(address account, bytes32 slot) external returns (bytes32);
    22
    
                                                    
                                                
    23
        // Stores a value to an address' storage slot
    24
        function store(address account, bytes32 slot, bytes32 value) external;
    25
    
                                                    
                                                
    26
        // Sets the *next* call's msg.sender to be the input address
    27
        function prank(address) external;
    28
    
                                                    
                                                
    29
        // Set msg.sender to the input address until the current call exits
    30
        function prankHere(address) external;
    31
    
                                                    
                                                
    32
        // Sets an address' balance
    33
        function deal(address who, uint256 newBalance) external;
    34
    
                                                    
                                                
    35
        // Sets an address' code
    36
        function etch(address who, bytes calldata code) external;
    37
    
                                                    
                                                
    38
        // Signs data
    39
        function sign(uint256 privateKey, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);
    40
    
                                                    
                                                
    41
        // Computes address for a given private key
    42
        function addr(uint256 privateKey) external returns (address);
    43
    
                                                    
                                                
    44
        // Gets the nonce of an account
    45
        function getNonce(address account) external returns (uint64);
    46
    
                                                    
                                                
    47
        // Sets the nonce of an account
    48
        // The new nonce must be higher than the current nonce of the account
    49
        function setNonce(address account, uint64 nonce) external;
    50
    
                                                    
                                                
    51
        // Performs a foreign function call via terminal
    52
        function ffi(string[] calldata) external returns (bytes memory);
    53
    
                                                    
                                                
    54
        // Take a snapshot of the current state of the EVM
    55
        function snapshot() external returns (uint256);
    56
    
                                                    
                                                
    57
        // Revert state back to a snapshot
    58
        function revertTo(uint256) external returns (bool);
    59
    
                                                    
                                                
    60
        // Convert Solidity types to strings
    61
        function toString(address) external returns (string memory);
    62
        function toString(bytes calldata) external returns (string memory);
    63
        function toString(bytes32) external returns (string memory);
    64
        function toString(bool) external returns (string memory);
    65
        function toString(uint256) external returns (string memory);
    66
        function toString(int256) external returns (string memory);
    67
    
                                                    
                                                
    68
        // Convert strings into Solidity types
    69
        function parseBytes(string memory) external returns (bytes memory);
    70
        function parseBytes32(string memory) external returns (bytes32);
    71
        function parseAddress(string memory) external returns (address);
    72
        function parseUint(string memory) external returns (uint256);
    73
        function parseInt(string memory) external returns (int256);
    74
        function parseBool(string memory) external returns (bool);
    75
    }
    76
    
                                                    
                                                
    77
    
                                                    
                                                
    78
    
                                                    
                                                
    79
    
                                                    
                                                
    80
    
                                                    
                                                
    81
    
                                                    
                                                
    82
    
                                                    
                                                
    83
    
                                                    
                                                
    84
    
                                                    
                                                
    85
    
                                                    
                                                
    86
    
                                                    
                                                
    87
    
                                                    
                                                
    88
    
                                                    
                                                
    89
    
                                                    
                                                
    90
    
                                                    
                                                
    91
    
                                                    
                                                
    92
    
                                                    
                                                
    93
    
                                                    
                                                
    94
    
                                                    
                                                
    95
    
                                                    
                                                
    96
    
                                                    
                                                
    97
    
                                                    
                                                
    98
    
                                                    
                                                
    99
    
                                                    
                                                
    100
    
                                                    
                                                
    101
    
                                                    
                                                
    102
    
                                                    
                                                
    103
    
                                                    
                                                
    104
    
                                                    
                                                
    105
    
                                                    
                                                
    106
    
                                                    
                                                
    107
    
                                                    
                                                
    108
    
                                                    
                                                
    109
    
                                                    
                                                
    110
    
                                                    
                                                
    111
    
                                                    
                                                
    112
    
                                                    
                                                
    113
    
                                                    
                                                
    114
    
                                                    
                                                
    115
    
                                                    
                                                
    116
    
                                                    
                                                
    117
    
                                                    
                                                
    118
    
                                                    
                                                
    119
    
                                                    
                                                
    120
    
                                                    
                                                
    121
    
                                                    
                                                
    122
    
                                                    
                                                
    123
    
                                                    
                                                
    124
    
                                                    
                                                
    125
    
                                                    
                                                
    126
    
                                                    
                                                
    127
    
                                                    
                                                
    128
    
                                                    
                                                
    129
    
                                                    
                                                
    130
    
                                                    
                                                
    131
    
                                                    
                                                
    132
    
                                                    
                                                
    133
    
                                                    
                                                
    134
    
                                                    
                                                
    135
    
                                                    
                                                
    136
    
                                                    
                                                
    137
    
                                                    
                                                
    138
    
                                                    
                                                
    139
    
                                                    
                                                
    140
    
                                                    
                                                
    141
    
                                                    
                                                
    142
    
                                                    
                                                
    143
    
                                                    
                                                
    144
    
                                                    
                                                
    145
    
                                                    
                                                
    146
    
                                                    
                                                
    147
    
                                                    
                                                
    148
    
                                                    
                                                
    149
    
                                                    
                                                
    150
    
                                                    
                                                
    151
    
                                                    
                                                
    152
    
                                                    
                                                
    153
    
                                                    
                                                
    100.0% test/Invariant/Utils/PropertyHelper.sol
    Lines covered: 8 / 8 (100.0%)
    1
    // SPDX-License-Identifier: AGPL-3.0-or-later
    2
    pragma solidity ^0.8.0;
    3
    
                                                    
                                                
    4
    abstract contract PropertiesAsserts {
    5
        event LogUint256(string, uint256);
    6
        event LogAddress(string, address);
    7
        event LogString(string);
    8
    
                                                    
                                                
    9
        event AssertFail(string);
    10
        event AssertEqFail(string);
    11
        event AssertNeqFail(string);
    12
        event AssertGteFail(string);
    13
        event AssertGtFail(string);
    14
        event AssertLteFail(string);
    15
        event AssertLtFail(string);
    16
    
                                                    
                                                
    17
        function assertWithMsg(bool b, string memory reason) internal {
    18
            if (!b) {
    19
                emit AssertFail(reason);
    20
                assert(false);
    21
            }
    22
        }
    23
    
                                                    
                                                
    24
        /// @notice asserts that a is equal to b. Violations are logged using reason.
    25
        function assertEq(uint256 a, uint256 b, string memory reason) internal {
    26
            if (a != b) {
    27
                string memory aStr = PropertiesLibString.toString(a);
    28
                string memory bStr = PropertiesLibString.toString(b);
    29
                bytes memory assertMsg = abi.encodePacked(
    30
                    "Invalid: ",
    31
                    aStr,
    32
                    "!=",
    33
                    bStr,
    34
                    ", reason: ",
    35
                    reason
    36
                );
    37
                emit AssertEqFail(string(assertMsg));
    38
                assert(false);
    39
            }
    40
        }
    41
    
                                                    
                                                
    42
        /// @notice int256 version of assertEq
    43
        function assertEq(int256 a, int256 b, string memory reason) internal {
    44
            if (a != b) {
    45
                string memory aStr = PropertiesLibString.toString(a);
    46
                string memory bStr = PropertiesLibString.toString(b);
    47
                bytes memory assertMsg = abi.encodePacked(
    48
                    "Invalid: ",
    49
                    aStr,
    50
                    "!=",
    51
                    bStr,
    52
                    ", reason: ",
    53
                    reason
    54
                );
    55
                emit AssertEqFail(string(assertMsg));
    56
                assert(false);
    57
            }
    58
        }
    59
    
                                                    
                                                
    60
        /// @notice asserts that a is not equal to b. Violations are logged using reason.
    61
        function assertNeq(uint256 a, uint256 b, string memory reason) internal {
    62
            if (a == b) {
    63
                string memory aStr = PropertiesLibString.toString(a);
    64
                string memory bStr = PropertiesLibString.toString(b);
    65
                bytes memory assertMsg = abi.encodePacked(
    66
                    "Invalid: ",
    67
                    aStr,
    68
                    "==",
    69
                    bStr,
    70
                    ", reason: ",
    71
                    reason
    72
                );
    73
                emit AssertNeqFail(string(assertMsg));
    74
                assert(false);
    75
            }
    76
        }
    77
    
                                                    
                                                
    78
        /// @notice int256 version of assertNeq
    79
        function assertNeq(int256 a, int256 b, string memory reason) internal {
    80
            if (a == b) {
    81
                string memory aStr = PropertiesLibString.toString(a);
    82
                string memory bStr = PropertiesLibString.toString(b);
    83
                bytes memory assertMsg = abi.encodePacked(
    84
                    "Invalid: ",
    85
                    aStr,
    86
                    "==",
    87
                    bStr,
    88
                    ", reason: ",
    89
                    reason
    90
                );
    91
                emit AssertNeqFail(string(assertMsg));
    92
                assert(false);
    93
            }
    94
        }
    95
    
                                                    
                                                
    96
        /// @notice asserts that a is greater than or equal to b. Violations are logged using reason.
    97
        function assertGte(uint256 a, uint256 b, string memory reason) internal {
    98
            if (!(a >= b)) {
    99
                string memory aStr = PropertiesLibString.toString(a);
    100
                string memory bStr = PropertiesLibString.toString(b);
    101
                bytes memory assertMsg = abi.encodePacked(
    102
                    "Invalid: ",
    103
                    aStr,
    104
                    "<",
    105
                    bStr,
    106
                    " failed, reason: ",
    107
                    reason
    108
                );
    109
                emit AssertGteFail(string(assertMsg));
    110
                assert(false);
    111
            }
    112
        }
    113
    
                                                    
                                                
    114
        /// @notice int256 version of assertGte
    115
        function assertGte(int256 a, int256 b, string memory reason) internal {
    116
            if (!(a >= b)) {
    117
                string memory aStr = PropertiesLibString.toString(a);
    118
                string memory bStr = PropertiesLibString.toString(b);
    119
                bytes memory assertMsg = abi.encodePacked(
    120
                    "Invalid: ",
    121
                    aStr,
    122
                    "<",
    123
                    bStr,
    124
                    " failed, reason: ",
    125
                    reason
    126
                );
    127
                emit AssertGteFail(string(assertMsg));
    128
                assert(false);
    129
            }
    130
        }
    131
    
                                                    
                                                
    132
        /// @notice asserts that a is greater than b. Violations are logged using reason.
    133
        function assertGt(uint256 a, uint256 b, string memory reason) internal {
    134
            if (!(a > b)) {
    135
                string memory aStr = PropertiesLibString.toString(a);
    136
                string memory bStr = PropertiesLibString.toString(b);
    137
                bytes memory assertMsg = abi.encodePacked(
    138
                    "Invalid: ",
    139
                    aStr,
    140
                    "<=",
    141
                    bStr,
    142
                    " failed, reason: ",
    143
                    reason
    144
                );
    145
                emit AssertGtFail(string(assertMsg));
    146
                assert(false);
    147
            }
    148
        }
    149
    
                                                    
                                                
    150
        /// @notice int256 version of assertGt
    151
        function assertGt(int256 a, int256 b, string memory reason) internal {
    152
            if (!(a > b)) {
    153
                string memory aStr = PropertiesLibString.toString(a);
    154
                string memory bStr = PropertiesLibString.toString(b);
    155
                bytes memory assertMsg = abi.encodePacked(
    156
                    "Invalid: ",
    157
                    aStr,
    158
                    "<=",
    159
                    bStr,
    160
                    " failed, reason: ",
    161
                    reason
    162
                );
    163
                emit AssertGtFail(string(assertMsg));
    164
                assert(false);
    165
            }
    166
        }
    167
    
                                                    
                                                
    168
        /// @notice asserts that a is less than or equal to b. Violations are logged using reason.
    169
        function assertLte(uint256 a, uint256 b, string memory reason) internal {
    170
            if (!(a <= b)) {
    171
                string memory aStr = PropertiesLibString.toString(a);
    172
                string memory bStr = PropertiesLibString.toString(b);
    173
                bytes memory assertMsg = abi.encodePacked(
    174
                    "Invalid: ",
    175
                    aStr,
    176
                    ">",
    177
                    bStr,
    178
                    " failed, reason: ",
    179
                    reason
    180
                );
    181
                emit AssertLteFail(string(assertMsg));
    182
                assert(false);
    183
            }
    184
        }
    185
    
                                                    
                                                
    186
        /// @notice int256 version of assertLte
    187
        function assertLte(int256 a, int256 b, string memory reason) internal {
    188
            if (!(a <= b)) {
    189
                string memory aStr = PropertiesLibString.toString(a);
    190
                string memory bStr = PropertiesLibString.toString(b);
    191
                bytes memory assertMsg = abi.encodePacked(
    192
                    "Invalid: ",
    193
                    aStr,
    194
                    ">",
    195
                    bStr,
    196
                    " failed, reason: ",
    197
                    reason
    198
                );
    199
                emit AssertLteFail(string(assertMsg));
    200
                assert(false);
    201
            }
    202
        }
    203
    
                                                    
                                                
    204
        /// @notice asserts that a is less than b. Violations are logged using reason.
    205
        function assertLt(uint256 a, uint256 b, string memory reason) internal {
    206
            if (!(a < b)) {
    207
                string memory aStr = PropertiesLibString.toString(a);
    208
                string memory bStr = PropertiesLibString.toString(b);
    209
                bytes memory assertMsg = abi.encodePacked(
    210
                    "Invalid: ",
    211
                    aStr,
    212
                    ">=",
    213
                    bStr,
    214
                    " failed, reason: ",
    215
                    reason
    216
                );
    217
                emit AssertLtFail(string(assertMsg));
    218
                assert(false);
    219
            }
    220
        }
    221
    
                                                    
                                                
    222
        /// @notice int256 version of assertLt
    223
        function assertLt(int256 a, int256 b, string memory reason) internal {
    224
            if (!(a < b)) {
    225
                string memory aStr = PropertiesLibString.toString(a);
    226
                string memory bStr = PropertiesLibString.toString(b);
    227
                bytes memory assertMsg = abi.encodePacked(
    228
                    "Invalid: ",
    229
                    aStr,
    230
                    ">=",
    231
                    bStr,
    232
                    " failed, reason: ",
    233
                    reason
    234
                );
    235
                emit AssertLtFail(string(assertMsg));
    236
                assert(false);
    237
            }
    238
        }
    239
    
                                                    
                                                
    240
        /// @notice Clamps value to be between low and high, both inclusive
    241
        function clampBetween(
    242
            uint256 value,
    243
            uint256 low,
    244
            uint256 high
    245
        ) internal returns (uint256) {
    246
    ✓ 2.4K
            if (value < low || value > high) {
    247
                uint ans = low + (value % (high - low + 1));
    248
    ✓ 2.2K
                string memory valueStr = PropertiesLibString.toString(value);
    249
    ✓ 2.2K
                string memory ansStr = PropertiesLibString.toString(ans);
    250
    ✓ 2.2K
                bytes memory message = abi.encodePacked(
    251
                    "Clamping value ",
    252
                    valueStr,
    253
                    " to ",
    254
                    ansStr
    255
                );
    256
    ✓ 2.2K
                emit LogString(string(message));
    257
    ✓ 2.2K
                return ans;
    258
            }
    259
            return value;
    260
        }
    261
    
                                                    
                                                
    262
        /// @notice int256 version of clampBetween
    263
        function clampBetween(
    264
            int256 value,
    265
            int256 low,
    266
            int256 high
    267
        ) internal returns (int256) {
    268
            if (value < low || value > high) {
    269
                int range = high - low + 1;
    270
                int clamped = (value - low) % (range);
    271
                if (clamped < 0) clamped += range;
    272
                int ans = low + clamped;
    273
                string memory valueStr = PropertiesLibString.toString(value);
    274
                string memory ansStr = PropertiesLibString.toString(ans);
    275
                bytes memory message = abi.encodePacked(
    276
                    "Clamping value ",
    277
                    valueStr,
    278
                    " to ",
    279
                    ansStr
    280
                );
    281
                emit LogString(string(message));
    282
                return ans;
    283
            }
    284
            return value;
    285
        }
    286
    
                                                    
                                                
    287
        /// @notice clamps a to be less than b
    288
        function clampLt(uint256 a, uint256 b) internal returns (uint256) {
    289
            if (!(a < b)) {
    290
                assertNeq(
    291
                    b,
    292
                    0,
    293
                    "clampLt cannot clamp value a to be less than zero. Check your inputs/assumptions."
    294
                );
    295
                uint256 value = a % b;
    296
                string memory aStr = PropertiesLibString.toString(a);
    297
                string memory valueStr = PropertiesLibString.toString(value);
    298
                bytes memory message = abi.encodePacked(
    299
                    "Clamping value ",
    300
                    aStr,
    301
                    " to ",
    302
                    valueStr
    303
                );
    304
                emit LogString(string(message));
    305
                return value;
    306
            }
    307
            return a;
    308
        }
    309
    
                                                    
                                                
    310
        /// @notice int256 version of clampLt
    311
        function clampLt(int256 a, int256 b) internal returns (int256) {
    312
            if (!(a < b)) {
    313
                int256 value = b - 1;
    314
                string memory aStr = PropertiesLibString.toString(a);
    315
                string memory valueStr = PropertiesLibString.toString(value);
    316
                bytes memory message = abi.encodePacked(
    317
                    "Clamping value ",
    318
                    aStr,
    319
                    " to ",
    320
                    valueStr
    321
                );
    322
                emit LogString(string(message));
    323
                return value;
    324
            }
    325
            return a;
    326
        }
    327
    
                                                    
                                                
    328
        /// @notice clamps a to be less than or equal to b
    329
        function clampLte(uint256 a, uint256 b) internal returns (uint256) {
    330
            if (!(a <= b)) {
    331
                uint256 value = a % (b + 1);
    332
                string memory aStr = PropertiesLibString.toString(a);
    333
                string memory valueStr = PropertiesLibString.toString(value);
    334
                bytes memory message = abi.encodePacked(
    335
                    "Clamping value ",
    336
                    aStr,
    337
                    " to ",
    338
                    valueStr
    339
                );
    340
                emit LogString(string(message));
    341
                return value;
    342
            }
    343
            return a;
    344
        }
    345
    
                                                    
                                                
    346
        /// @notice int256 version of clampLte
    347
        function clampLte(int256 a, int256 b) internal returns (int256) {
    348
            if (!(a <= b)) {
    349
                int256 value = b;
    350
                string memory aStr = PropertiesLibString.toString(a);
    351
                string memory valueStr = PropertiesLibString.toString(value);
    352
                bytes memory message = abi.encodePacked(
    353
                    "Clamping value ",
    354
                    aStr,
    355
                    " to ",
    356
                    valueStr
    357
                );
    358
                emit LogString(string(message));
    359
                return value;
    360
            }
    361
            return a;
    362
        }
    363
    
                                                    
                                                
    364
        /// @notice clamps a to be greater than b
    365
        function clampGt(uint256 a, uint256 b) internal returns (uint256) {
    366
            if (!(a > b)) {
    367
                assertNeq(
    368
                    b,
    369
                    type(uint256).max,
    370
                    "clampGt cannot clamp value a to be larger than uint256.max. Check your inputs/assumptions."
    371
                );
    372
                uint256 value = b + 1;
    373
                string memory aStr = PropertiesLibString.toString(a);
    374
                string memory valueStr = PropertiesLibString.toString(value);
    375
                bytes memory message = abi.encodePacked(
    376
                    "Clamping value ",
    377
                    aStr,
    378
                    " to ",
    379
                    valueStr
    380
                );
    381
                emit LogString(string(message));
    382
                return value;
    383
            } else {
    384
                return a;
    385
            }
    386
        }
    387
    
                                                    
                                                
    388
        /// @notice int256 version of clampGt
    389
        function clampGt(int256 a, int256 b) internal returns (int256) {
    390
            if (!(a > b)) {
    391
                int256 value = b + 1;
    392
                string memory aStr = PropertiesLibString.toString(a);
    393
                string memory valueStr = PropertiesLibString.toString(value);
    394
                bytes memory message = abi.encodePacked(
    395
                    "Clamping value ",
    396
                    aStr,
    397
                    " to ",
    398
                    valueStr
    399
                );
    400
                emit LogString(string(message));
    401
                return value;
    402
            } else {
    403
                return a;
    404
            }
    405
        }
    406
    
                                                    
                                                
    407
        /// @notice clamps a to be greater than or equal to b
    408
        function clampGte(uint256 a, uint256 b) internal returns (uint256) {
    409
            if (!(a > b)) {
    410
                uint256 value = b;
    411
                string memory aStr = PropertiesLibString.toString(a);
    412
                string memory valueStr = PropertiesLibString.toString(value);
    413
                bytes memory message = abi.encodePacked(
    414
                    "Clamping value ",
    415
                    aStr,
    416
                    " to ",
    417
                    valueStr
    418
                );
    419
                emit LogString(string(message));
    420
                return value;
    421
            }
    422
            return a;
    423
        }
    424
    
                                                    
                                                
    425
        /// @notice int256 version of clampGte
    426
        function clampGte(int256 a, int256 b) internal returns (int256) {
    427
            if (!(a > b)) {
    428
                int256 value = b;
    429
                string memory aStr = PropertiesLibString.toString(a);
    430
                string memory valueStr = PropertiesLibString.toString(value);
    431
                bytes memory message = abi.encodePacked(
    432
                    "Clamping value ",
    433
                    aStr,
    434
                    " to ",
    435
                    valueStr
    436
                );
    437
                emit LogString(string(message));
    438
                return value;
    439
            }
    440
            return a;
    441
        }
    442
    }
    443
    
                                                    
                                                
    444
    /// @notice Efficient library for creating string representations of integers.
    445
    /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
    446
    /// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol)
    447
    /// @dev Name of the library is modified to prevent collisions with contract-under-test uses of LibString
    448
    ✓ 13
    library PropertiesLibString {
    449
        function toString(int256 value) internal pure returns (string memory str) {
    450
            uint256 absValue = value >= 0 ? uint256(value) : uint256(-value);
    451
            str = toString(absValue);
    452
    
                                                    
                                                
    453
            if (value < 0) {
    454
                str = string(abi.encodePacked("-", str));
    455
            }
    456
        }
    457
    
                                                    
                                                
    458
        function toString(uint256 value) internal pure returns (string memory str) {
    459
            /// @solidity memory-safe-assembly
    460
    ✓ 184.4K
            assembly {
    461
                // The maximum value of a uint256 contains 78 digits (1 byte per digit), but we allocate 160 bytes
    462
                // to keep the free memory pointer word aligned. We'll need 1 word for the length, 1 word for the
    463
                // trailing zeros padding, and 3 other words for a max of 78 digits. In total: 5 * 32 = 160 bytes.
    464
                let newFreeMemoryPointer := add(mload(0x40), 160)
    465
    
                                                    
                                                
    466
                // Update the free memory pointer to avoid overriding our string.
    467
                mstore(0x40, newFreeMemoryPointer)
    468
    
                                                    
                                                
    469
                // Assign str to the end of the zone of newly allocated memory.
    470
                str := sub(newFreeMemoryPointer, 32)
    471
    
                                                    
                                                
    472
                // Clean the last word of memory it may not be overwritten.
    473
                mstore(str, 0)
    474
    
                                                    
                                                
    475
                // Cache the end of the memory to calculate the length later.
    476
                let end := str
    477
    
                                                    
                                                
    478
                // We write the string from rightmost digit to leftmost digit.
    479
                // The following is essentially a do-while loop that also handles the zero case.
    480
                // prettier-ignore
    481
                for { let temp := value } 1 {} {
    482
                    // Move the pointer 1 byte to the left.
    483
                    str := sub(str, 1)
    484
    
                                                    
                                                
    485
                    // Write the character to the pointer.
    486
                    // The ASCII index of the '0' character is 48.
    487
                    mstore8(str, add(48, mod(temp, 10)))
    488
    
                                                    
                                                
    489
                    // Keep dividing temp until zero.
    490
                    temp := div(temp, 10)
    491
    
                                                    
                                                
    492
                     // prettier-ignore
    493
                    if iszero(temp) { break }
    494
                }
    495
    
                                                    
                                                
    496
                // Compute and cache the final total length of the string.
    497
                let length := sub(end, str)
    498
    
                                                    
                                                
    499
                // Move the pointer 32 bytes leftwards to make room for the length.
    500
                str := sub(str, 32)
    501
    
                                                    
                                                
    502
                // Store the string's length at the start of memory allocated for our string.
    503
                mstore(str, length)
    504
            }
    505
        }
    506
    
                                                    
                                                
    507
        function toString(address value) internal pure returns (string memory str) {
    508
            bytes memory s = new bytes(40);
    509
            for (uint i = 0; i < 20; i++) {
    510
                bytes1 b = bytes1(
    511
                    uint8(uint(uint160(value)) / (2 ** (8 * (19 - i))))
    512
                );
    513
                bytes1 hi = bytes1(uint8(b) / 16);
    514
                bytes1 lo = bytes1(uint8(b) - 16 * uint8(hi));
    515
                s[2 * i] = char(hi);
    516
                s[2 * i + 1] = char(lo);
    517
            }
    518
            return string(s);
    519
        }
    520
    
                                                    
                                                
    521
        function char(bytes1 b) internal pure returns (bytes1 c) {
    522
            if (uint8(b) < 10) return bytes1(uint8(b) + 0x30);
    523
            else return bytes1(uint8(b) + 0x57);
    524
        }
    525
    }
    0.0% test/KittyFiTest.t.sol
    Lines covered: 0 / 97 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    
                                                    
                                                
    3
    pragma solidity 0.8.26;
    4
    
                                                    
                                                
    5
    import { Test, console } from "forge-std/Test.sol";
    6
    import { KittyCoin } from "src/KittyCoin.sol";
    7
    import { KittyPool } from "src/KittyPool.sol";
    8
    import { KittyVault, IAavePool } from "src/KittyVault.sol";
    9
    import { DeployKittyFi, HelperConfig } from "script/DeployKittyFi.s.sol";
    10
    import { ERC20Mock } from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";
    11
    import { MockV3Aggregator } from "@chainlink/contracts/src/v0.8/tests/MockV3Aggregator.sol";
    12
    import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
    13
    
                                                    
                                                
    14
    contract KittyFiTest is Test {
    15
        KittyCoin kittyCoin;
    16
        KittyPool kittyPool;
    17
        KittyVault wethVault;
    18
        HelperConfig.NetworkConfig config;
    19
        address weth;
    20
        address meowntainer = makeAddr("meowntainer");
    21
        address user = makeAddr("user");
    22
        uint256 AMOUNT = 10e18;
    23
    
                                                    
                                                
    24
        function setUp() external {
    25
            HelperConfig helperConfig = new HelperConfig();
    26
            config = helperConfig.getNetworkConfig();
    27
            weth = config.weth;
    28
            deal(weth, user, AMOUNT);
    29
    
                                                    
                                                
    30
            kittyPool = new KittyPool(meowntainer, config.euroPriceFeed, config.aavePool);
    31
    
                                                    
                                                
    32
            vm.prank(meowntainer);
    33
            kittyPool.meownufactureKittyVault(config.weth, config.ethUsdPriceFeed);
    34
    
                                                    
                                                
    35
            kittyCoin = KittyCoin(kittyPool.getKittyCoin());
    36
            wethVault = KittyVault(kittyPool.getTokenToVault(config.weth));
    37
        }
    38
    
                                                    
                                                
    39
        function testConstructorValuesSetUpCorrectly() public view {
    40
            assertEq(address(kittyPool.getMeowntainer()), meowntainer);
    41
            assertEq(address(kittyPool.getKittyCoin()), address(kittyCoin));
    42
            assertEq(address(kittyPool.getTokenToVault(weth)), address(wethVault));
    43
            assertEq(address(kittyPool.getAavePool()), config.aavePool);
    44
        }
    45
    
                                                    
                                                
    46
        function test_OnlyMeowntainCanAddNewToken() public {
    47
            address attacker = makeAddr("attacker");
    48
    
                                                    
                                                
    49
            vm.startPrank(attacker);
    50
            ERC20Mock token = new ERC20Mock();
    51
            MockV3Aggregator priceFeed = new MockV3Aggregator(8, 1e8);
    52
    
                                                    
                                                
    53
            vm.expectRevert(abi.encodeWithSelector(KittyPool.KittyPool__NotMeowntainerPurrrrr.selector));
    54
            kittyPool.meownufactureKittyVault(address(token), address(priceFeed));
    55
            vm.stopPrank();
    56
        }
    57
    
                                                    
                                                
    58
        function test_MeowntainerAddingTokenSetUpCorrectly() public {
    59
            // initially there is no vault for wbtc
    60
            require(kittyPool.getTokenToVault(config.wbtc) == address(0));
    61
    
                                                    
                                                
    62
            vm.prank(meowntainer);
    63
            kittyPool.meownufactureKittyVault(config.wbtc, config.btcUsdPriceFeed);
    64
    
                                                    
                                                
    65
            address vaultCreated = kittyPool.getTokenToVault(config.wbtc);
    66
    
                                                    
                                                
    67
            require(vaultCreated != address(0), "Vault not created");
    68
    
                                                    
                                                
    69
            KittyVault _vault = KittyVault(vaultCreated);
    70
    
                                                    
                                                
    71
            assert(_vault.i_token() == config.wbtc);
    72
            assert(_vault.i_pool() == address(kittyPool));
    73
            assert(address(_vault.i_priceFeed()) == config.btcUsdPriceFeed);
    74
            assert(address(_vault.i_euroPriceFeed()) == config.euroPriceFeed);
    75
            assert(address(_vault.i_aavePool()) == config.aavePool);
    76
            assert(_vault.meowntainer() == meowntainer);
    77
            assert(address(_vault.i_aavePool()) == config.aavePool);
    78
        }
    79
    
                                                    
                                                
    80
        function test_UserDepositsInVault() public {
    81
            uint256 toDeposit = 5 ether;
    82
    
                                                    
                                                
    83
            vm.startPrank(user);
    84
    
                                                    
                                                
    85
            IERC20(weth).approve(address(wethVault), toDeposit);
    86
            kittyPool.depawsitMeowllateral(weth, toDeposit);
    87
    
                                                    
                                                
    88
            vm.stopPrank();
    89
    
                                                    
                                                
    90
            assertEq(wethVault.totalMeowllateralInVault(), toDeposit);
    91
            assertEq(wethVault.totalCattyNip(), toDeposit);
    92
            assertEq(wethVault.userToCattyNip(user), toDeposit);
    93
            assertEq(IERC20(weth).balanceOf(address(wethVault)), toDeposit);
    94
        }
    95
    
                                                    
                                                
    96
        function test_UserDepositsAndMintsKittyCoin() public {
    97
            uint256 toDeposit = 5 ether;
    98
            uint256 amountToMint = 20e18;       // 20 KittyCoin
    99
    
                                                    
                                                
    100
            vm.startPrank(user);
    101
    
                                                    
                                                
    102
            IERC20(weth).approve(address(wethVault), toDeposit);
    103
            kittyPool.depawsitMeowllateral(weth, toDeposit);
    104
    
                                                    
                                                
    105
            kittyPool.meowintKittyCoin(amountToMint);
    106
    
                                                    
                                                
    107
            vm.stopPrank();
    108
    
                                                    
                                                
    109
            assertEq(kittyPool.getKittyCoinMeownted(user), amountToMint);
    110
        }
    111
    
                                                    
                                                
    112
        function test_UserWithdrawCollateral() public {
    113
            uint256 toDeposit = 5 ether;
    114
    
                                                    
                                                
    115
            vm.startPrank(user);
    116
    
                                                    
                                                
    117
            IERC20(weth).approve(address(wethVault), toDeposit);
    118
            kittyPool.depawsitMeowllateral(weth, toDeposit);
    119
    
                                                    
                                                
    120
            vm.stopPrank();
    121
    
                                                    
                                                
    122
    
                                                    
                                                
    123
            // now user wants to withdraw 
    124
            uint256 toWithdraw = 3 ether;
    125
    
                                                    
                                                
    126
            vm.startPrank(user);
    127
    
                                                    
                                                
    128
            kittyPool.whiskdrawMeowllateral(weth, toWithdraw);
    129
    
                                                    
                                                
    130
            vm.stopPrank();
    131
    
                                                    
                                                
    132
            assertEq(wethVault.totalMeowllateralInVault(), toDeposit - toWithdraw);
    133
            assertEq(wethVault.totalCattyNip(), toDeposit - toWithdraw);
    134
            assertEq(wethVault.userToCattyNip(user), toDeposit - toWithdraw);
    135
            assertEq(IERC20(weth).balanceOf(address(wethVault)), toDeposit - toWithdraw);
    136
    
                                                    
                                                
    137
            assertEq(IERC20(weth).balanceOf(user), AMOUNT - toDeposit + toWithdraw);
    138
        }
    139
    
                                                    
                                                
    140
        function test_BurningKittyCoin() public {
    141
            uint256 toDeposit = 5 ether;
    142
            uint256 amountToMint = 20e18;       // 20 KittyCoin
    143
    
                                                    
                                                
    144
            vm.startPrank(user);
    145
    
                                                    
                                                
    146
            IERC20(weth).approve(address(wethVault), toDeposit);
    147
            kittyPool.depawsitMeowllateral(weth, toDeposit);
    148
    
                                                    
                                                
    149
            kittyPool.meowintKittyCoin(amountToMint);
    150
    
                                                    
                                                
    151
            vm.stopPrank();
    152
    
                                                    
                                                
    153
            // user burns 15 KittyCoin
    154
            uint256 toBurn = 15e18;
    155
    
                                                    
                                                
    156
            uint256 userBalPreBurn = kittyPool.getKittyCoinMeownted(user);
    157
    
                                                    
                                                
    158
            vm.prank(user);
    159
            kittyPool.burnKittyCoin(user, toBurn);
    160
    
                                                    
                                                
    161
            uint256 userBalPostBurn = kittyPool.getKittyCoinMeownted(user);
    162
    
                                                    
                                                
    163
            assert(kittyPool.getKittyCoinMeownted(user) == amountToMint - toBurn);
    164
            assert(userBalPreBurn > userBalPostBurn);
    165
        }
    166
    
                                                    
                                                
    167
        modifier userDepositsCollateral() {
    168
            uint256 toDeposit = 5 ether;
    169
            vm.startPrank(user);
    170
            IERC20(weth).approve(address(wethVault), toDeposit);
    171
            kittyPool.depawsitMeowllateral(weth, toDeposit);
    172
            vm.stopPrank();
    173
            _;
    174
        }
    175
    
                                                    
                                                
    176
        function test_supplyingCollateralToAave() public userDepositsCollateral {
    177
            uint256 totalDepositedInVault = 5 ether;
    178
    
                                                    
                                                
    179
            // meowntainer transfers collateral in eth vault to Aave to earn interest
    180
            uint256 toSupply = 3 ether;
    181
    
                                                    
                                                
    182
            vm.prank(meowntainer);
    183
            wethVault.purrrCollateralToAave(toSupply);
    184
    
                                                    
                                                
    185
            assertEq(wethVault.totalMeowllateralInVault(), totalDepositedInVault - toSupply);
    186
    
                                                    
                                                
    187
            uint256 totalCollateralBase = wethVault.getTotalMeowllateralInAave();
    188
    
                                                    
                                                
    189
            assert(totalCollateralBase > 0);
    190
        }
    191
    
                                                    
                                                
    192
        function test_supplyAndWithdrawCollateralFromAave() public userDepositsCollateral {
    193
            uint256 totalDepositedInVault = 5 ether;
    194
    
                                                    
                                                
    195
            // meowntainer transfers collateral in eth vault to Aave to earn interest
    196
            uint256 toSupply = 3 ether;
    197
    
                                                    
                                                
    198
            vm.prank(meowntainer);
    199
            wethVault.purrrCollateralToAave(toSupply);
    200
    
                                                    
                                                
    201
            // now withdrawing whole collateral deposited
    202
    
                                                    
                                                
    203
            vm.prank(meowntainer);
    204
            wethVault.purrrCollateralFromAave(toSupply);
    205
    
                                                    
                                                
    206
            assertEq(wethVault.totalMeowllateralInVault(), totalDepositedInVault);
    207
    
                                                    
                                                
    208
            assert(wethVault.getTotalMeowllateralInAave() == 0);
    209
        }
    210
    }